@tt-a1i/openpi 0.5.0 → 0.6.0

package/extensions/shared/completion-inbox.ts

@@ -0,0 +1,193 @@
+export type CompletionProducer = "subagent" | "workflow" | "background";
+export type CompletionWakePolicy =
+  | "follow-up"
+  | "next-turn"
+  | "producer-policy";
+
+export interface CompletionOwner {
+  readonly sessionId: string;
+  readonly epoch: number;
+}
+
+export interface CompletionSessionIdentity {
+  getSessionId(): string;
+}
+
+/** Transport metadata only; producer state remains the terminal authority. */
+export interface CompletionEnvelope<T> {
+  readonly deliveryId: string;
+  readonly owner: CompletionOwner;
+  readonly producer: CompletionProducer;
+  readonly producerId: string;
+  readonly terminalRef: unknown;
+  readonly wake: CompletionWakePolicy;
+  readonly payload: T;
+}
+
+export interface CompletionDeadLetter {
+  readonly deliveryId: string;
+  readonly producer: CompletionProducer;
+  readonly producerId: string;
+  readonly failure: "owner-unavailable" | "stale-owner";
+}
+
+function sameOwner(left: CompletionOwner, right: CompletionOwner) {
+  return (
+    Boolean(left.sessionId) &&
+    left.sessionId !== "unowned" &&
+    left.sessionId === right.sessionId &&
+    left.epoch === right.epoch
+  );
+}
+
+let nextOwnerEpoch = 1;
+const ownerBySessionIdentity = new WeakMap<object, CompletionOwner>();
+
+/**
+ * Bind one process-local generation to a Pi SessionManager identity.
+ *
+ * All OpenPI producers observing the same manager share an owner. A replaced
+ * manager, or a manager whose Session id changes, receives a new epoch so late
+ * callbacks cannot target the replacement transcript.
+ */
+export function completionOwnerFor(
+  identity: CompletionSessionIdentity,
+): CompletionOwner {
+  const sessionId = identity.getSessionId();
+  const existing = ownerBySessionIdentity.get(identity);
+  if (existing?.sessionId === sessionId) return existing;
+  const owner = { sessionId, epoch: nextOwnerEpoch++ };
+  ownerBySessionIdentity.set(identity, owner);
+  return owner;
+}
+
+/**
+ * One atomic consumption gate shared by all background producers.
+ *
+ * Claim removes before transport; a failed transport retries the exact
+ * envelopes. A successful transport leaves them consumed. No execution facts
+ * or result bytes are stored here.
+ */
+export function createCompletionInbox<T>() {
+  const pending = new Map<string, CompletionEnvelope<T>>();
+  const inFlight = new Map<string, CompletionEnvelope<T>>();
+  const deadLetters: CompletionDeadLetter[] = [];
+
+  const reject = (
+    envelope: CompletionEnvelope<T>,
+    failure: CompletionDeadLetter["failure"],
+  ) => {
+    deadLetters.push({
+      deliveryId: envelope.deliveryId,
+      producer: envelope.producer,
+      producerId: envelope.producerId,
+      failure,
+    });
+    return false;
+  };
+
+  const admit = (
+    envelope: CompletionEnvelope<T>,
+    owner: CompletionOwner | undefined,
+  ) => {
+    if (!owner) return reject(envelope, "owner-unavailable");
+    if (!sameOwner(envelope.owner, owner)) {
+      return reject(envelope, "stale-owner");
+    }
+    pending.set(envelope.deliveryId, envelope);
+    return true;
+  };
+
+  /** Restore a failed attempt ahead of completions that arrived meanwhile. */
+  const retry = (
+    envelopes: readonly CompletionEnvelope<T>[],
+    owner: CompletionOwner | undefined,
+  ) => {
+    const current = [...pending.values()];
+    pending.clear();
+    for (const envelope of envelopes) {
+      inFlight.delete(envelope.deliveryId);
+      admit(envelope, owner);
+    }
+    for (const envelope of current) admit(envelope, owner);
+  };
+
+  return {
+    defer(envelope: CompletionEnvelope<T>, owner: CompletionOwner | undefined) {
+      return admit(envelope, owner);
+    },
+
+    /** Explicit status/wait and automatic delivery atomically race here. */
+    consume(producer: CompletionProducer, producerIds: Iterable<string>) {
+      const ids = new Set(producerIds);
+      for (const [deliveryId, envelope] of pending) {
+        if (envelope.producer === producer && ids.has(envelope.producerId)) {
+          pending.delete(deliveryId);
+          inFlight.delete(deliveryId);
+        }
+      }
+    },
+
+    consumeDeliveryIds(deliveryIds: Iterable<string>) {
+      for (const deliveryId of deliveryIds) {
+        pending.delete(deliveryId);
+        inFlight.delete(deliveryId);
+      }
+    },
+
+    claim(
+      owner: CompletionOwner | undefined,
+      maximum = Number.POSITIVE_INFINITY,
+    ) {
+      const claimed: CompletionEnvelope<T>[] = [];
+      for (const [deliveryId, envelope] of pending) {
+        if (claimed.length >= maximum) break;
+        pending.delete(deliveryId);
+        if (!owner) {
+          reject(envelope, "owner-unavailable");
+          continue;
+        }
+        if (!sameOwner(envelope.owner, owner)) {
+          reject(envelope, "stale-owner");
+          continue;
+        }
+        inFlight.set(deliveryId, envelope);
+        claimed.push(envelope);
+      }
+      return claimed;
+    },
+
+    retry,
+
+    retryClaimed(
+      producer: CompletionProducer,
+      producerIds: Iterable<string>,
+      owner: CompletionOwner | undefined,
+    ) {
+      const ids = new Set(producerIds);
+      const envelopes = [...inFlight.values()].filter(
+        (envelope) =>
+          envelope.producer === producer && ids.has(envelope.producerId),
+      );
+      retry(envelopes, owner);
+    },
+
+    acknowledge(deliveryIds: Iterable<string>) {
+      for (const deliveryId of deliveryIds) inFlight.delete(deliveryId);
+    },
+
+    size() {
+      return pending.size;
+    },
+
+    inspectDeadLetters() {
+      return [...deadLetters];
+    },
+
+    clear() {
+      pending.clear();
+      inFlight.clear();
+      deadLetters.length = 0;
+    },
+  };
+}

package/extensions/shared/setup-config.ts

@@ -63,6 +63,9 @@ export type FooterLines = readonly (readonly FooterLayoutItem[])[];
 export const DETAIL_DISPLAYS = ["full", "compact"] as const;
 export type DetailDisplay = (typeof DETAIL_DISPLAYS)[number];
 
+export const WEB_THEMES = ["system", "light", "dark"] as const;
+export type WebTheme = (typeof WEB_THEMES)[number];
+
 export const CAPABILITY_DISCOVERY_MODES = ["explicit", "adaptive"] as const;
 export type CapabilityDiscoveryMode =
   (typeof CAPABILITY_DISCOVERY_MODES)[number];
@@ -149,6 +152,7 @@ export interface MyPiSetupConfig {
     readonly maxAgentCalls: number;
   };
   readonly ui: {
+    readonly webTheme: WebTheme;
     readonly showHeader: boolean;
     readonly customFooter: boolean;
     readonly footerStyle: FooterStyle;
@@ -179,6 +183,7 @@ export const DEFAULT_SETUP_CONFIG: MyPiSetupConfig = {
     maxAgentCalls: DEFAULT_WORKFLOW_MAX_AGENT_CALLS,
   },
   ui: {
+    webTheme: "system",
     showHeader: false,
     customFooter: true,
     footerStyle: DEFAULT_FOOTER_STYLE,
@@ -226,6 +231,9 @@ const isCapabilityDiscoveryMode = (
   typeof value === "string" &&
   CAPABILITY_DISCOVERY_MODES.includes(value as CapabilityDiscoveryMode);
 
+const isWebTheme = (value: unknown): value is WebTheme =>
+  typeof value === "string" && WEB_THEMES.includes(value as WebTheme);
+
 export function flattenFooterItems(lines: FooterLines): readonly FooterItem[] {
   const items: FooterItem[] = [];
   const seen = new Set<FooterItem>();
@@ -485,6 +493,7 @@ export function parseSetupConfig(value: unknown): MyPiSetupConfig {
       ),
     },
     ui: {
+      webTheme: isWebTheme(ui.webTheme) ? ui.webTheme : "system",
       showHeader: typeof ui.showHeader === "boolean" ? ui.showHeader : false,
       customFooter:
         typeof ui.customFooter === "boolean" ? ui.customFooter : true,
@@ -1016,7 +1025,7 @@ export function formatSetupConfig(config = loadSetupConfig()) {
     `Capability discovery: ${config.capabilities.discovery}`,
     suggestions,
     `Workflows: ${config.workflows.concurrency} concurrent agents · ${config.workflows.maxAgentCalls} total calls`,
-    `UI: large header ${config.ui.showHeader ? "on" : "off"} · custom footer ${footer}`,
+    `UI: Web theme ${config.ui.webTheme} · large header ${config.ui.showHeader ? "on" : "off"} · custom footer ${footer}`,
     `Subagent results: ${config.ui.subagentResultDisplay === "full" ? "full by default" : "compact status summary (Ctrl+O expands full output)"}`,
     `Bash operations: ${config.ui.bashToolDisplay === "full" ? "expanded by default" : "one-line activity summary (Ctrl+O restores native evidence)"}`,
     `Write/Edit operations: ${config.ui.fileMutationDisplay === "full" ? "expanded by default" : "one-line activity summary (Ctrl+O restores native evidence)"}`,

package/extensions/shared/structured-output.ts

@@ -0,0 +1,154 @@
+import {
+  defineTool,
+  type ToolDefinition,
+} from "@earendil-works/pi-coding-agent";
+import { type TSchema, Type } from "typebox";
+
+export const STRUCTURED_OUTPUT_SYSTEM_INSTRUCTION =
+  "When your task is complete, call the `structured_output` tool exactly once as your final action, with fields matching the required schema. Do not write any other text after it.";
+
+export const STRUCTURED_OUTPUT_TOOL_DESCRIPTION =
+  "Return your final result as structured data matching the required schema. Call this exactly once, as your last action; do not write any other text after it.";
+
+export const STRUCTURED_RESULT_LIMITS = Object.freeze({
+  schemaDepth: 24,
+  schemaNodes: 10_000,
+  resultBytes: 2 * 1024 * 1024,
+  resultDepth: 24,
+  resultNodes: 100_000,
+  resultStringBytes: 1024 * 1024,
+});
+
+export interface EncodedStructuredResult {
+  readonly value: unknown;
+  readonly json: string;
+  readonly byteLength: number;
+}
+
+function safeRecordKey(key: string) {
+  return key !== "__proto__" && key !== "constructor" && key !== "prototype";
+}
+
+/** Preserve the caller's full JSON Schema instead of lossy keyword conversion. */
+export function jsonSchemaToTypebox(schema: unknown): TSchema {
+  if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
+    throw new Error("structured output schema must be a bounded JSON object");
+  }
+  const seen = new WeakSet<object>();
+  let nodes = 0;
+  const validate = (current: unknown, depth: number): boolean => {
+    if (
+      ++nodes > STRUCTURED_RESULT_LIMITS.schemaNodes ||
+      depth > STRUCTURED_RESULT_LIMITS.schemaDepth
+    ) {
+      return false;
+    }
+    if (
+      current === null ||
+      typeof current === "string" ||
+      typeof current === "boolean"
+    ) {
+      return true;
+    }
+    if (typeof current === "number") return Number.isFinite(current);
+    if (Array.isArray(current)) {
+      return current.every((item) => validate(item, depth + 1));
+    }
+    if (typeof current !== "object" || seen.has(current)) return false;
+    seen.add(current);
+    return Object.keys(current).every(
+      (key) =>
+        safeRecordKey(key) &&
+        validate((current as Record<string, unknown>)[key], depth + 1),
+    );
+  };
+  if (!validate(schema, 0)) {
+    throw new Error("structured output schema must be a bounded JSON object");
+  }
+  return Type.Unsafe(schema);
+}
+
+/** Encode one complete JSON result or fail before any truncated artifact exists. */
+export function encodeStructuredResult(
+  value: unknown,
+): EncodedStructuredResult {
+  const seen = new WeakSet<object>();
+  let nodes = 0;
+  const validate = (current: unknown, depth: number): void => {
+    if (++nodes > STRUCTURED_RESULT_LIMITS.resultNodes) {
+      throw new Error("structured result exceeds the node limit");
+    }
+    if (depth > STRUCTURED_RESULT_LIMITS.resultDepth) {
+      throw new Error("structured result exceeds the depth limit");
+    }
+    if (typeof current === "string") {
+      if (
+        Buffer.byteLength(current, "utf8") >
+        STRUCTURED_RESULT_LIMITS.resultStringBytes
+      ) {
+        throw new Error("structured result contains an oversized string");
+      }
+      return;
+    }
+    if (
+      current === null ||
+      typeof current === "boolean" ||
+      (typeof current === "number" && Number.isFinite(current))
+    ) {
+      return;
+    }
+    if (typeof current !== "object" || seen.has(current)) {
+      throw new Error(
+        "structured result must contain only acyclic JSON values",
+      );
+    }
+    seen.add(current);
+    if (Array.isArray(current)) {
+      for (const item of current) validate(item, depth + 1);
+      return;
+    }
+    for (const [key, item] of Object.entries(current)) {
+      if (!safeRecordKey(key)) {
+        throw new Error("structured result contains an unsafe object key");
+      }
+      validate(item, depth + 1);
+    }
+  };
+  validate(value, 0);
+  const json = JSON.stringify(value);
+  const byteLength = Buffer.byteLength(json, "utf8");
+  if (byteLength > STRUCTURED_RESULT_LIMITS.resultBytes) {
+    throw new Error("structured result exceeds the total byte limit");
+  }
+  return { value, json, byteLength };
+}
+
+/** One-shot terminating child tool shared by Workflow and Direct Subagent. */
+export function createStructuredOutputTool(
+  schema: unknown,
+  capture: (value: unknown) => void,
+): ToolDefinition {
+  return defineTool({
+    name: "structured_output",
+    label: "Structured Output",
+    description: STRUCTURED_OUTPUT_TOOL_DESCRIPTION,
+    parameters: jsonSchemaToTypebox(schema),
+    async execute(_toolCallId, params) {
+      capture(params);
+      return {
+        content: [{ type: "text", text: "Recorded structured result." }],
+        details: params,
+        terminate: true,
+      };
+    },
+  });
+}
+
+export function childToolsWithStructuredOutput(
+  tools: readonly string[] | undefined,
+  structured: boolean,
+) {
+  return tools
+    ? [...new Set([...tools, ...(structured ? ["structured_output"] : [])])]
+    : undefined;
+}

package/extensions/subagents/index.ts

@@ -60,6 +60,7 @@ import {
   resolveStandaloneChildProjectTrust,
 } from "../shared/child-session.ts";
 import { formatContextUtilization } from "../shared/context-utilization.ts";
+import { completionOwnerFor } from "../shared/completion-inbox.ts";
 import {
   registerEditorLayer,
   removeEditorLayer,
@@ -169,6 +170,7 @@ interface SpawnResultDetails {
   readonly harness?: string;
   readonly model?: string;
   readonly agentType?: string;
+  readonly structured?: boolean;
 }
 
 interface SubagentFinishedData {
@@ -187,6 +189,8 @@ interface SubagentResultDetails {
   readonly elapsed?: string;
   readonly artifactSaveFailed?: boolean;
   readonly fullResultSaved?: boolean;
+  readonly structured?: unknown;
+  readonly structuredArtifactPath?: string;
   readonly count?: number;
   readonly results?: ReadonlyArray<{
     readonly id: string;
@@ -197,6 +201,8 @@ interface SubagentResultDetails {
     readonly elapsed?: string;
     readonly artifactSaveFailed?: boolean;
     readonly fullResultSaved?: boolean;
+    readonly structured?: unknown;
+    readonly structuredArtifactPath?: string;
   }>;
   /** Display-only projection for the custom message renderer. */
   readonly displayContent?: string;
@@ -227,13 +233,17 @@ function describeSubagent(snap: SubagentSnapshot) {
   return `${snap.id} [${snap.status}] "${snap.title}" (${details.join(", ")})`;
 }
 
+function subagentResultContent(snap: SubagentSnapshot) {
+  return snap.structuredResult?.json ?? (snap.finalText || "(no output)");
+}
+
 export function truncatedOutput(
   snap: SubagentSnapshot,
   maxBytes = SUBAGENT_OUTPUT_MAX_BYTES,
   writeArtifact: (content: string) => string = (content) =>
     persistResultArtifact(getAgentDir(), content),
 ): string {
-  const output = snap.finalText || "(no output)";
+  const output = subagentResultContent(snap);
   return projectResult(output, {
     maxBytes: Math.min(maxBytes, DEFAULT_MAX_BYTES),
     maxLines: Math.min(600, DEFAULT_MAX_LINES),
@@ -245,7 +255,7 @@ function projectSubagentOutput(
   snap: SubagentSnapshot,
   maxBytes: number,
 ): ResultProjection {
-  const output = snap.finalText || "(no output)";
+  const output = subagentResultContent(snap);
   return projectResult(output, {
     maxBytes: Math.min(maxBytes, DEFAULT_MAX_BYTES),
     maxLines: Math.min(600, DEFAULT_MAX_LINES),
@@ -313,7 +323,7 @@ export function createSubagentResultDispatcher(
     );
     const allocation = allocateResultBudgets(
       snaps.map((snap) =>
-        Buffer.byteLength(snap.finalText || "(no output)", "utf8"),
+        Buffer.byteLength(subagentResultContent(snap), "utf8"),
       ),
       getContextUsage(),
       {
@@ -370,6 +380,13 @@ export function createSubagentResultDispatcher(
             ...(projections[0]!.artifactSaveFailed
               ? { artifactSaveFailed: true }
               : {}),
+            ...(snaps[0]!.structuredResult
+              ? {
+                  structured: snaps[0]!.structuredResult.value,
+                  structuredArtifactPath:
+                    snaps[0]!.structuredResult.artifactPath,
+                }
+              : {}),
           }
         : {
             count: snaps.length,
@@ -388,6 +405,12 @@ export function createSubagentResultDispatcher(
               ...(projections[index]!.artifactSaveFailed
                 ? { artifactSaveFailed: true }
                 : {}),
+              ...(snap.structuredResult
+                ? {
+                    structured: snap.structuredResult.value,
+                    structuredArtifactPath: snap.structuredResult.artifactPath,
+                  }
+                : {}),
             })),
           };
     pi.appendEntry<SubagentResultEntryData>("subagent-result", {
@@ -514,6 +537,10 @@ export default function (
   );
   const resultDelivery = createSubagentResultDelivery<SubagentSnapshot>({
     isIdle: () => sessionContext?.isIdle() === true,
+    owner: () =>
+      sessionContext
+        ? completionOwnerFor(sessionContext.sessionManager)
+        : undefined,
     // Every unconsumed fire-and-forget result must reach the parent. The
     // delivery coordinator batches results that settled while it was busy.
     deliver: dispatchResults,
@@ -931,6 +958,9 @@ export default function (
         ...(agentType?.body ? { appendSystemPrompt: [agentType.body] } : {}),
         ...(childTools ? { tools: childTools } : {}),
         ...(agentType ? { agentTypeName: agentType.name } : {}),
+        ...(params.output_schema !== undefined
+          ? { outputSchema: params.output_schema }
+          : {}),
         ...(worktree ? { worktree: { ...worktree, repoCwd: cwd } } : {}),
         parent: {
           parentCwd: ctx.cwd,
@@ -1000,6 +1030,9 @@ export default function (
               ...(worktree ? { worktreeBranch: worktree.branch } : {}),
               ...(agentType ? { agentTypeName: agentType.name } : {}),
               ...(childTools ? { tools: childTools } : {}),
+              ...(params.output_schema !== undefined
+                ? { structured: true }
+                : {}),
             }),
           },
         ],
@@ -1010,6 +1043,7 @@ export default function (
           harness,
           model: snap.meta.modelLabel,
           ...(agentType ? { agentType: agentType.name } : {}),
+          ...(params.output_schema !== undefined ? { structured: true } : {}),
         },
       };
     },
@@ -1132,7 +1166,7 @@ export default function (
       );
       const allocation = allocateResultBudgets(
         resultEntries.map(({ snap }) =>
-          Buffer.byteLength(snap.finalText || "(no output)", "utf8"),
+          Buffer.byteLength(subagentResultContent(snap), "utf8"),
         ),
         ctx.getContextUsage(),
         {
@@ -1182,6 +1216,12 @@ export default function (
               ...(artifactSaveFailures.has(id)
                 ? { artifactSaveFailed: true }
                 : {}),
+              ...(snap?.structuredResult
+                ? {
+                    structured: snap.structuredResult.value,
+                    structuredArtifactPath: snap.structuredResult.artifactPath,
+                  }
+                : {}),
             };
           }),
         },

package/extensions/subagents/src/backends/pi.ts

@@ -19,6 +19,7 @@ import type {
 } from "@earendil-works/pi-coding-agent";
 import {
   createAgentSession,
+  getAgentDir,
   SessionManager,
 } from "@earendil-works/pi-coding-agent";
 import type { Cause, Scope } from "effect";
@@ -49,6 +50,14 @@ import {
   reclaimWorktree,
 } from "../../../shared/worktree.ts";
 import { AgentToolRenderLedger } from "../../../shared/agent-tool-renderer.ts";
+import {
+  childToolsWithStructuredOutput,
+  createStructuredOutputTool,
+  encodeStructuredResult,
+  type EncodedStructuredResult,
+  STRUCTURED_OUTPUT_SYSTEM_INSTRUCTION,
+} from "../../../shared/structured-output.ts";
+import { persistStructuredResultArtifact } from "../result-artifact.ts";
 
 const DIRECT_WORKTREE_CLEANUP_TIMEOUT_MS = 4_000;
 const PARTIAL_TEXT_MAX_LENGTH = 128 * 1_024;
@@ -198,14 +207,26 @@ const makePiSession = (
     const thinkingLevel = (task.reasoningEffort ??
       task.parent.inheritedThinkingLevel) as ThinkingLevel | undefined;
 
+    let capturedStructured: EncodedStructuredResult | undefined;
+    const structuredOutputTool =
+      task.outputSchema === undefined
+        ? undefined
+        : createStructuredOutputTool(task.outputSchema, (value) => {
+            capturedStructured = encodeStructuredResult(value);
+          });
+
     const session = yield* Effect.tryPromise({
       try: async () => {
+        const appendSystemPrompt = [
+          ...(task.appendSystemPrompt ?? []),
+          ...(structuredOutputTool
+            ? [STRUCTURED_OUTPUT_SYSTEM_INSTRUCTION]
+            : []),
+        ];
         const { loader, settingsManager } = await createChildResources({
           cwd: task.cwd,
           projectTrusted: task.parent.projectTrusted,
-          ...(task.appendSystemPrompt
-            ? { appendSystemPrompt: [...task.appendSystemPrompt] }
-            : {}),
+          ...(appendSystemPrompt.length > 0 ? { appendSystemPrompt } : {}),
         });
         const { session } = await (
           options.sessionFactory ?? createAgentSession
@@ -216,13 +237,27 @@ const makePiSession = (
           resourceLoader: loader,
           model,
           thinkingLevel,
-          ...childToolPolicy(task.tools),
+          ...(structuredOutputTool
+            ? { customTools: [structuredOutputTool] }
+            : {}),
+          ...childToolPolicy(
+            childToolsWithStructuredOutput(
+              task.tools,
+              structuredOutputTool !== undefined,
+            ),
+          ),
         });
         // Start child extension session hooks/resources in headless mode.
         // A rejection here would otherwise leak the freshly created session:
         // the scope finalizer that owns cleanup is only registered later.
         try {
-          await bindChildSessionExtensions(session, task.tools);
+          await bindChildSessionExtensions(
+            session,
+            childToolsWithStructuredOutput(
+              task.tools,
+              structuredOutputTool !== undefined,
+            ),
+          );
         } catch (error) {
           await shutdownAndDisposeChildSession(session, {
             timeoutMs: options.shutdownTimeoutMs,
@@ -338,11 +373,46 @@ const makePiSession = (
         });
         return;
       }
+      if (task.outputSchema !== undefined && capturedStructured === undefined) {
+        emit({
+          _tag: "RunSettled",
+          outcome: {
+            _tag: "Failed",
+            errorText:
+              "Agent finished without calling structured_output; no structured result matching output_schema was produced.",
+            partialText,
+          },
+        });
+        return;
+      }
+      let structuredResult;
+      if (capturedStructured) {
+        try {
+          structuredResult = {
+            ...capturedStructured,
+            artifactPath: persistStructuredResultArtifact(
+              getAgentDir(),
+              capturedStructured.json,
+            ),
+          };
+        } catch (error) {
+          emit({
+            _tag: "RunSettled",
+            outcome: {
+              _tag: "Failed",
+              errorText: `Structured result artifact could not be persisted: ${boundedError(error)}`,
+              partialText,
+            },
+          });
+          return;
+        }
+      }
       emit({
         _tag: "RunSettled",
         outcome: {
           _tag: "Completed",
           finalText: prompt.finalText,
+          ...(structuredResult ? { structuredResult } : {}),
         },
       });
     };
@@ -597,6 +667,7 @@ const makePiSession = (
         promise: Promise.resolve(),
       };
       state.activePrompt = activePrompt;
+      capturedStructured = undefined;
       state.settled = false;
       emit({ _tag: "RunStarted" });
       let prompt: Promise<void>;