Release v0.2.29

Author: dxcodeagent

RELEASE.json

@@ -1,13 +1,13 @@
 {
-  "version": "0.2.28",
+  "version": "0.2.29",
   "license": "FSL-1.1-ALv2",
   "baselineSha256": "7847f65a9b20b366a60d52d19ca3cd6bdd1bb09b8cb506659a270f27a21d8877",
   "e2b": {
     "recipeSha256": "761809ee2efa2b6c750451ace29283cbb8e55b6ce3b5b14c2bb4509df71df801",
     "profileSha256": "414dbecee2d47de36016ea05c736e2edff3a0deb298babf923887ea184a01c10"
   },
   "dxd": {
-    "url": "https://github.com/dxcode-dev/dxcode/releases/download/v0.2.28/dxd-linux-x64",
+    "url": "https://github.com/dxcode-dev/dxcode/releases/download/v0.2.29/dxd-linux-x64",
     "sha256": "76f424e6253874df89ceeb8f42d2f2a67ff3024d4116639cec5d04624ab4f345"
   },
   "toolchain": {

alchemy.run.ts

@@ -1038,7 +1038,12 @@ export default Alchemy.Stack(
           ...(configuration.environment !== "staging"
             ? { DX_PREVIEW_DXD_SHA256: configuration.dxdChecksum }
             : {}),
-          DX_PREVIEW_WORKER_ID: worker.workerId,
+          // Alchemy knows a Worker's ID before an update deploys it; pairing
+          // it with the hash makes Verify wait for the new version.
+          DX_PREVIEW_WORKER_ID: Output.map(
+            Output.all(worker.workerId, worker.hash),
+            ([workerId]) => workerId,
+          ),
           DX_PREVIEW_BOOTSTRAP: Output.map(bootstrap.hash.input, () => "ready"),
         },
         memo: false,

apps/core/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dx/core",
   "private": true,
-  "version": "0.2.28",
+  "version": "0.2.29",
   "license": "FSL-1.1-ALv2",
   "type": "module",
   "scripts": {
@@ -20,7 +20,7 @@
     "@dx/api": "workspace:^",
     "@dx/domain": "workspace:^",
     "@effect/sql-d1": "4.0.5",
-    "@flue/runtime": "file:../../third-party/flue/runtime-e7bef20be3c74f4ffdeeed83b1fe161a1fb5f0c8.tgz",
+    "@flue/runtime": "file:../../third-party/flue/runtime-33a2cf7e3796a7f3960a24455f3c5bb57537ee13.tgz",
     "@jitl/quickjs-wasmfile-release-sync": "0.32.0",
     "@logtape/logtape": "2.3.1",
     "@modelcontextprotocol/client": "2.0.0",
@@ -42,9 +42,9 @@
     "@cloudflare/vite-plugin": "1.53.0",
     "@cloudflare/vitest-plugin": "1.0.0",
     "@cloudflare/workers-types": "5.20260820.1",
-    "@earendil-works/pi-ai": "0.85.1",
-    "@flue/sdk": "file:../../third-party/flue/sdk-e7bef20be3c74f4ffdeeed83b1fe161a1fb5f0c8.tgz",
-    "@flue/vite": "file:../../third-party/flue/vite-e7bef20be3c74f4ffdeeed83b1fe161a1fb5f0c8.tgz",
+    "@earendil-works/pi-ai": "1.1.0",
+    "@flue/sdk": "file:../../third-party/flue/sdk-33a2cf7e3796a7f3960a24455f3c5bb57537ee13.tgz",
+    "@flue/vite": "file:../../third-party/flue/vite-33a2cf7e3796a7f3960a24455f3c5bb57537ee13.tgz",
     "@msw/cloudflare": "^0.0.1",
     "@types/ws": "8.18.1",
     "@valibot/to-json-schema": "1.7.1",

apps/core/src/claude-code/claude-code.test.ts

@@ -9,10 +9,11 @@ import {
 } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import type {
-  AssistantMessage,
-  AssistantMessageEvent,
-  Context,
+import {
+  type AssistantMessage,
+  type AssistantMessageEvent,
+  type Context,
+  normalizeContext,
 } from "@earendil-works/pi-ai";
 import type { Sandbox } from "@flue/runtime";
 import { local } from "@flue/runtime/node";
@@ -261,9 +262,11 @@ const claudeCode = (
     /** One Flue model call; resolves with its final event. */
     answer: async (context: Context, signal?: AbortSignal) => {
       const events: AssistantMessageEvent[] = [];
-      for await (const next of provider.streamSimple(model, context, {
-        ...(signal === undefined ? {} : { signal }),
-      }))
+      for await (const next of provider.streamSimple(
+        model,
+        normalizeContext(context),
+        { ...(signal === undefined ? {} : { signal }) },
+      ))
         events.push(next);
       const last = events.at(-1);
       if (last === undefined) throw new Error("Expected an event.");

apps/core/src/claude-code/provider.ts

@@ -14,6 +14,8 @@ import {
   type Context,
   createAssistantMessageEventStream,
   createProvider,
+  getCurrentSystemPrompt,
+  type JsonObject,
   type Model,
   type SimpleStreamOptions,
   type Usage,
@@ -133,7 +135,7 @@ const contentFor = (block: ClaudeCodeBlock): Content => {
         type: "toolCall",
         id: block.id,
         name: call.name,
-        arguments: call.arguments,
+        arguments: call.arguments as JsonObject,
       };
     }
   }
@@ -628,7 +630,8 @@ export const createClaudeCodeProvider = (deps: ClaudeCodeProviderDeps) => {
               effort: claudeCodeEffort(
                 options?.reasoning ?? CLAUDE_CODE_DEFAULT_EFFORT,
               ),
-              systemPrompt: context.systemPrompt ?? "",
+              // pi carries the prompt as transcript system messages.
+              systemPrompt: getCurrentSystemPrompt(context.messages),
               input: input(),
               token: credential.token,
               tools: claudeCodeDxToolList(threadId),

apps/core/src/cloudflare.ts

@@ -54,8 +54,11 @@ if (
     ...getBuiltinProviders(),
     "cloudflare",
     "github-copilot",
+    "azure-openai-responses",
   ]) {
-    if (providerId === "cloudflare-workers-ai") continue;
+    // dx's canonical ids for these pi providers are registered above.
+    if (providerId === "cloudflare-workers-ai" || providerId === "azure")
+      continue;
     const { provider, options } = createDxModelRoutingProvider(
       providerId,
       deps,

apps/core/src/execution/e2b/default-tools.test.ts

@@ -1,3 +1,4 @@
+import { getCurrentTools } from "@earendil-works/pi-ai";
 import {
   fauxAssistantMessage,
   fauxProvider,
@@ -13,7 +14,7 @@ it("exposes only dx's workspace tools to the model", async () => {
   let toolNames: string[] = [];
   provider.setResponses([
     (context) => {
-      toolNames = context.tools?.map((tool) => tool.name) ?? [];
+      toolNames = getCurrentTools(context.messages).map((tool) => tool.name);
       return fauxAssistantMessage("done");
     },
   ]);

apps/core/src/observability/flue.ts

@@ -30,6 +30,42 @@ const correlations = (event: FlueObservation) => ({
     : { submissionId: event.submissionId }),
 });
 
+// Failure text from the provider or runtime, never model output. Bounded so
+// a provider that echoes a large request cannot flood the log.
+const ERROR_TEXT_LIMIT = 2_000;
+const bounded = (text: string | undefined) =>
+  text === undefined || text === ""
+    ? undefined
+    : text.slice(0, ERROR_TEXT_LIMIT);
+
+const failure = (error: {
+  type?: string;
+  name?: string;
+  code?: string;
+  message?: string;
+  details?: string;
+}) => {
+  const fields = {
+    errorType: error.type,
+    errorName: error.name,
+    errorCode: error.code,
+    errorMessage: bounded(error.message),
+    errorDetails: bounded(error.details),
+  };
+  return Object.fromEntries(
+    Object.entries(fields).filter(([, value]) => value !== undefined),
+  );
+};
+
+const unknownFailure = (error: unknown) =>
+  error instanceof Error
+    ? failure({ name: error.name, message: error.message })
+    : typeof error === "string"
+      ? failure({ message: error })
+      : error === undefined
+        ? {}
+        : failure({ message: JSON.stringify(error) });
+
 const observeFlueEvent = (
   event: FlueObservation,
   context: FlueEventContext,
@@ -154,10 +190,30 @@ const observeFlueEvent = (
       });
       return persistence;
     case "submission_settled":
-      agentLifecycleLogger.info("Flue submission settled.", {
+      if (event.outcome === "failed")
+        agentLifecycleLogger.error("Flue submission failed.", {
+          event: event.type,
+          ...correlations(event),
+          outcome: event.outcome,
+          ...(event.error === undefined ? {} : failure(event.error)),
+        });
+      else
+        agentLifecycleLogger.info("Flue submission settled.", {
+          event: event.type,
+          ...correlations(event),
+          outcome: event.outcome,
+        });
+      return persistence;
+    case "submission_recovery":
+      agentLifecycleLogger.warn("Flue submission recovery step failed.", {
         event: event.type,
         ...correlations(event),
+        kind: event.kind,
+        operation: event.operation,
         outcome: event.outcome,
+        attemptCount: event.attemptCount,
+        maxAttempts: event.maxAttempts,
+        ...(event.error === undefined ? {} : failure(event.error)),
       });
       return persistence;
     case "turn_start":
@@ -182,7 +238,7 @@ const observeFlueEvent = (
       return persistence;
     case "turn": {
       const usage = event.response.usage;
-      agentModelLogger.info("Flue model turn completed.", {
+      const fields = {
         event: event.type,
         ...correlations(event),
         turnId: event.turnId,
@@ -191,6 +247,17 @@ const observeFlueEvent = (
         requestedModel: event.request.requestedModel,
         durationMs: event.durationMs,
         isError: event.isError,
+        ...(event.isError
+          ? {
+              finishReason: event.response.finishReason,
+              providerFinishReason: event.response.providerFinishReason,
+              // Flue copies an in-band failure, such as Claude Code's, from
+              // the assistant message into this error.
+              ...(event.response.error === undefined
+                ? {}
+                : failure(event.response.error)),
+            }
+          : {}),
         ...(usage === undefined
           ? {}
           : {
@@ -200,7 +267,10 @@ const observeFlueEvent = (
               cacheWriteTokens: usage.cacheWrite,
               totalTokens: usage.totalTokens,
             }),
-      });
+      };
+      if (event.isError)
+        agentModelLogger.error("Flue model turn failed.", fields);
+      else agentModelLogger.info("Flue model turn completed.", fields);
       return persistence;
     }
     case "compaction_start":
@@ -211,16 +281,23 @@ const observeFlueEvent = (
         estimatedTokens: event.estimatedTokens,
       });
       return persistence;
-    case "compaction":
-      agentModelLogger.info("Flue compaction completed.", {
+    case "compaction": {
+      const fields = {
         event: event.type,
         ...correlations(event),
         isError: event.isError,
         messagesBefore: event.messagesBefore,
         messagesAfter: event.messagesAfter,
         durationMs: event.durationMs,
-      });
+      };
+      if (event.isError)
+        agentModelLogger.error("Flue compaction failed.", {
+          ...fields,
+          ...unknownFailure(event.error),
+        });
+      else agentModelLogger.info("Flue compaction completed.", fields);
       return persistence;
+    }
     case "tool_start":
       agentToolLogger.info("Flue tool execution started.", {
         event: event.type,

apps/core/src/runtime/model-fixtures.test.ts

@@ -1,4 +1,7 @@
-import type { AssistantMessageEvent, Context } from "@earendil-works/pi-ai";
+import {
+  type AssistantMessageEvent,
+  normalizeContext,
+} from "@earendil-works/pi-ai";
 import { describe, expect, it } from "vitest";
 import {
   createLocalModelFixtureProvider,
@@ -7,15 +10,16 @@ import {
   localModelFixtureForPrompt,
 } from "./model-fixtures.js";
 
-const context = (prompt: string): Context => ({
-  messages: [
-    {
-      role: "user",
-      content: [{ type: "text", text: prompt }],
-      timestamp: 0,
-    },
-  ],
-});
+const context = (prompt: string) =>
+  normalizeContext({
+    messages: [
+      {
+        role: "user",
+        content: [{ type: "text", text: prompt }],
+        timestamp: 0,
+      },
+    ],
+  });
 
 describe("local model fixtures", () => {
   it("fails unknown prompts closed before any provider transport", () => {
@@ -66,20 +70,23 @@ describe("local model fixtures", () => {
     });
 
     const continued: AssistantMessageEvent[] = [];
-    for await (const event of provider.stream(model, {
-      messages: [
-        ...context(LOCAL_MODEL_FIXTURE_PROMPTS.toolContinuation).messages,
-        toolUse.message,
-        {
-          role: "toolResult",
-          toolCallId: "dx-local-fixture-write",
-          toolName: "create_file",
-          content: [{ type: "text", text: "Successfully wrote 25 bytes" }],
-          isError: false,
-          timestamp: 0,
-        },
-      ],
-    }))
+    for await (const event of provider.stream(
+      model,
+      normalizeContext({
+        messages: [
+          ...context(LOCAL_MODEL_FIXTURE_PROMPTS.toolContinuation).messages,
+          toolUse.message,
+          {
+            role: "toolResult",
+            toolCallId: "dx-local-fixture-write",
+            toolName: "create_file",
+            content: [{ type: "text", text: "Successfully wrote 25 bytes" }],
+            isError: false,
+            timestamp: 0,
+          },
+        ],
+      }),
+    ))
       continued.push(event);
     expect(continued.at(-1)).toMatchObject({
       type: "done",
@@ -95,20 +102,23 @@ describe("local model fixtures", () => {
     });
 
     expect(() =>
-      provider.stream(model, {
-        messages: [
-          ...context(LOCAL_MODEL_FIXTURE_PROMPTS.toolContinuation).messages,
-          toolUse.message,
-          {
-            role: "toolResult",
-            toolCallId: "dx-local-fixture-write",
-            toolName: "create_file",
-            content: [{ type: "text", text: "write failed" }],
-            isError: true,
-            timestamp: 0,
-          },
-        ],
-      }),
+      provider.stream(
+        model,
+        normalizeContext({
+          messages: [
+            ...context(LOCAL_MODEL_FIXTURE_PROMPTS.toolContinuation).messages,
+            toolUse.message,
+            {
+              role: "toolResult",
+              toolCallId: "dx-local-fixture-write",
+              toolName: "create_file",
+              content: [{ type: "text", text: "write failed" }],
+              isError: true,
+              timestamp: 0,
+            },
+          ],
+        }),
+      ),
     ).toThrow(LocalModelFixtureMismatch);
   });
 });