@tt-a1i/openpi 0.5.0 → 0.6.1

package/extensions/shared/child-session.ts

@@ -173,9 +173,6 @@ function packageSourceValue(source: PackageSource) {
 
 const CHILD_DISABLED_OPENPI_EXTENSION =
   "-extensions/git-info/index.ts" as const;
-const OPENPI_GIT_INFO_EXTENSION_PATH = realpathSync.native(
-  fileURLToPath(new URL("../git-info/index.ts", import.meta.url)),
-);
 
 function canonicalExistingPath(value: string) {
   try {
@@ -185,15 +182,38 @@ function canonicalExistingPath(value: string) {
   }
 }
 
+/**
+ * ENOENT means git-info is truly absent (trimmed fork, partial install):
+ * nothing to exclude. Any other failure (permissions, symlink loops) means we
+ * cannot verify the Git-polling extension is present, so fail closed instead
+ * of running a child with an unverifiable extension.
+ */
+export function resolveGitInfoPathOrThrow(
+  resolve: (value: string) => string = realpathSync.native,
+): string | undefined {
+  try {
+    return resolve(
+      fileURLToPath(new URL("../git-info/index.ts", import.meta.url)),
+    );
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
+    throw error;
+  }
+}
+
 function excludeOpenPiGitInfoExtension(
   resources: LoadExtensionsResult,
+  resolve: (value: string) => string = realpathSync.native,
 ): LoadExtensionsResult {
+  const gitInfoPath = resolveGitInfoPathOrThrow(resolve);
+  // undefined = absent (ENOENT): nothing to exclude. Non-ENOENT failures
+  // throw from resolveGitInfoPathOrThrow and fail child creation upstream.
+  if (gitInfoPath === undefined) return resources;
   return {
     ...resources,
     extensions: resources.extensions.filter(
       (extension) =>
-        canonicalExistingPath(extension.resolvedPath) !==
-        OPENPI_GIT_INFO_EXTENSION_PATH,
+        canonicalExistingPath(extension.resolvedPath) !== gitInfoPath,
     ),
   };
 }
@@ -530,6 +550,20 @@ export function effectiveChildToolAllowlist(tools?: readonly string[]) {
   );
 }
 
+/** Project the parent's active surface into a child; a role can only narrow it.
+ * Active tools are a visibility choice, not a filesystem/network sandbox.
+ * Inactive tools are not implicitly activated by delegation.
+ */
+export function inheritedChildToolAllowlist(
+  parentTools: readonly string[],
+  roleTools?: readonly string[],
+) {
+  const allowed = roleTools === undefined ? undefined : new Set(roleTools);
+  return effectiveChildToolAllowlist([...new Set(parentTools)])!.filter(
+    (name) => allowed === undefined || allowed.has(name),
+  );
+}
+
 export function childToolPolicy(tools?: readonly string[]) {
   const effectiveTools = effectiveChildToolAllowlist(tools);
   return {

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

@@ -57,9 +57,11 @@ import {
 } from "../shared/below-editor-navigation.ts";
 import {
   effectiveChildToolAllowlist,
+  inheritedChildToolAllowlist,
   resolveStandaloneChildProjectTrust,
 } from "../shared/child-session.ts";
 import { formatContextUtilization } from "../shared/context-utilization.ts";
+import { completionOwnerFor } from "../shared/completion-inbox.ts";
 import {
   registerEditorLayer,
   removeEditorLayer,
@@ -143,6 +145,7 @@ import { createSubagentResultDelivery } from "./src/result-delivery.ts";
 import {
   createSubagentRuntime,
   runTool,
+  SubagentToolInterruptedError,
   type SubagentRuntime,
 } from "./src/runtime.ts";
 import { openSubagentPicker, openSubagentTakeover } from "./src/ui/takeover.ts";
@@ -169,6 +172,7 @@ interface SpawnResultDetails {
   readonly harness?: string;
   readonly model?: string;
   readonly agentType?: string;
+  readonly structured?: boolean;
 }
 
 interface SubagentFinishedData {
@@ -187,6 +191,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 +203,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 +235,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 +257,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 +325,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 +382,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 +407,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 +539,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,
@@ -859,6 +888,7 @@ export default function (
       if (
         planning &&
         agentType &&
+        !agentType.planningCompatible &&
         !planModeAllowsDeclaredTools(declaredChildTools)
       ) {
         throw new Error(
@@ -907,7 +937,10 @@ export default function (
       const requestedChildTools = planning
         ? planModeChildTools(declaredChildTools)
         : declaredChildTools;
-      const childTools = effectiveChildToolAllowlist(requestedChildTools);
+      const childTools = inheritedChildToolAllowlist(
+        pi.getActiveTools(),
+        requestedChildTools,
+      );
       // Read at spawn time so `/openpi-setup` changes affect the next child
       // without reloading this extension. Undefined preserves parent-model
       // inheritance in the backend.
@@ -931,6 +964,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,
@@ -950,11 +986,22 @@ export default function (
           interruptMessage: "Subagent spawn aborted.",
         });
       } catch (error) {
-        // The session scope owns reclamation, but it never opened, so this
-        // worktree would otherwise be orphaned on disk.
+        // Known startup failures can reclaim their empty checkout. Interrupted
+        // startup must preserve it while asynchronous acquisition may continue.
         if (worktree) {
           const spawnError =
             error instanceof Error ? error.message : String(error);
+          // Cancelling Effect acquisition does not prove an asynchronous
+          // factory or extension hook has quiesced. It may still use this cwd.
+          if (
+            signal?.aborted ||
+            error instanceof SubagentToolInterruptedError
+          ) {
+            throw new Error(
+              `${spawnError}; startup quiescence is unknown; checkout preserved at ${worktree.path} (branch ${worktree.branch})`,
+              { cause: error },
+            );
+          }
           let cleanupWarning: string | undefined;
           let cleanupError: unknown;
           try {
@@ -1000,6 +1047,9 @@ export default function (
               ...(worktree ? { worktreeBranch: worktree.branch } : {}),
               ...(agentType ? { agentTypeName: agentType.name } : {}),
               ...(childTools ? { tools: childTools } : {}),
+              ...(params.output_schema !== undefined
+                ? { structured: true }
+                : {}),
             }),
           },
         ],
@@ -1010,6 +1060,7 @@ export default function (
           harness,
           model: snap.meta.modelLabel,
           ...(agentType ? { agentType: agentType.name } : {}),
+          ...(params.output_schema !== undefined ? { structured: true } : {}),
         },
       };
     },
@@ -1132,7 +1183,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 +1233,12 @@ export default function (
               ...(artifactSaveFailures.has(id)
                 ? { artifactSaveFailed: true }
                 : {}),
+              ...(snap?.structuredResult
+                ? {
+                    structured: snap.structuredResult.value,
+                    structuredArtifactPath: snap.structuredResult.artifactPath,
+                  }
+                : {}),
             };
           }),
         },