@bolt-foundry/gambit-core 0.8.5-rc.9 → 0.8.5

package/esm/src/runtime.js

@@ -1,6 +1,6 @@
 import * as dntShim from "../_dnt.shims.js";
 import * as path from "../deps/jsr.io/@std/path/1.1.4/mod.js";
-import { DEFAULT_GUARDRAILS, DEFAULT_STATUS_DELAY_MS, GAMBIT_TOOL_COMPLETE, GAMBIT_TOOL_CONTEXT, GAMBIT_TOOL_END, GAMBIT_TOOL_INIT, GAMBIT_TOOL_RESPOND, } from "./constants.js";
+import { DEFAULT_GUARDRAILS, DEFAULT_STATUS_DELAY_MS, GAMBIT_TOOL_CONTEXT, GAMBIT_TOOL_END, GAMBIT_TOOL_INIT, GAMBIT_TOOL_RESPOND, } from "./constants.js";
 import { loadDeck } from "./loader.js";
 import { canReadPath, canRunCommand, canRunPath, canWritePath, intersectPermissions, resolveEffectivePermissions, } from "./permissions.js";
 import { ExecToolUnsupportedHostError, executeBuiltinCommand, } from "./runtime_exec_host.js";
@@ -21,6 +21,7 @@ const WORKER_SANDBOX_ENV = "GAMBIT_DECK_WORKER_SANDBOX";
 const WORKER_TIMEOUT_MESSAGE = "Timeout exceeded";
 const RUN_CANCELED_MESSAGE = "Run canceled";
 const WORKER_SANDBOX_SIGNAL_UNSUPPORTED_MESSAGE = "workerSandbox is unsupported when `signal` is provided.";
+const INTERMEDIATE_OUTPUT_DISALLOWED_CODE = "intermediate_output_disallowed";
 const INSPECT_WORKER_TIMEOUT_MS = 1_500;
 const INSPECT_WORKER_TIMEOUT_MESSAGE = "Deck inspection timed out";
 const BUILTIN_TOOL_READ_FILE = "read_file";
@@ -28,12 +29,21 @@ const BUILTIN_TOOL_LIST_DIR = "list_dir";
 const BUILTIN_TOOL_GREP_FILES = "grep_files";
 const BUILTIN_TOOL_APPLY_PATCH = "apply_patch";
 const BUILTIN_TOOL_EXEC = "exec";
+const BUILTIN_TOOL_EMIT_OUTPUT_ITEM = "gambit_emit_output_item";
+const BUILTIN_TOOL_CONSUME_ASYNC_ACTION = "gambit_consume_async_action";
+const ASYNC_ACTION_JOBS_META_KEY = "gambit_async_action_jobs_v1";
+const ASYNC_ACTION_JOBS_META_VERSION = 1;
+const ASYNC_ACTION_JOB_INTERRUPTED_CODE = "async_action_interrupted";
+const ASYNC_ACTION_JOB_MAX_WAIT_MS = 5000;
+const ASYNC_ACTION_JOB_MAX_EVENTS = 512;
 const BUILTIN_TOOL_NAMES = new Set([
     BUILTIN_TOOL_READ_FILE,
     BUILTIN_TOOL_LIST_DIR,
     BUILTIN_TOOL_GREP_FILES,
     BUILTIN_TOOL_APPLY_PATCH,
     BUILTIN_TOOL_EXEC,
+    BUILTIN_TOOL_EMIT_OUTPUT_ITEM,
+    BUILTIN_TOOL_CONSUME_ASYNC_ACTION,
 ]);
 const TRUSTED_SCHEMA_IMPORT_PREFIXES = [
     "@bolt-foundry/gambit-core/schemas",
@@ -166,7 +176,10 @@ function normalizePermissionBaseDir(set, baseDir) {
     };
 }
 function deadlineForRun(guardrails, existing) {
-    const timeoutDeadline = performance.now() + guardrails.timeoutMs;
+    const timeoutMs = guardrails.timeoutMs === 0
+        ? Number.POSITIVE_INFINITY
+        : guardrails.timeoutMs;
+    const timeoutDeadline = performance.now() + timeoutMs;
     if (typeof existing === "number" && Number.isFinite(existing)) {
         return Math.min(existing, timeoutDeadline);
     }
@@ -193,6 +206,22 @@ function ensureRunActive(deadlineMs, signal) {
     throwIfCanceled(signal);
     ensureNotExpired(deadlineMs);
 }
+function mergeAbortSignals(signalA, signalB) {
+    if (!signalA)
+        return signalB;
+    if (!signalB)
+        return signalA;
+    if (signalA.aborted || signalB.aborted) {
+        const controller = new AbortController();
+        controller.abort();
+        return controller.signal;
+    }
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    signalA.addEventListener("abort", abort, { once: true });
+    signalB.addEventListener("abort", abort, { once: true });
+    return controller.signal;
+}
 function isTrustedSchemaImportKey(key) {
     const normalized = key.trim();
     if (!normalized)
@@ -329,7 +358,7 @@ export async function runDeck(opts) {
     if (workerSandboxRequested && !isWorkerSandboxHostSupported()) {
         throw new WorkerSandboxUnsupportedHostError();
     }
-    if (workerSandboxRequested && opts.signal) {
+    if (workerSandboxRequested && opts.signal && inferredRoot) {
         throw new WorkerSandboxSignalUnsupportedError();
     }
     const workerSandbox = workerSandboxRequested;
@@ -425,6 +454,9 @@ export async function runDeck(opts) {
                     responsesMode: opts.responsesMode,
                     permissions: permissions.effective,
                     permissionsTrace: permissions.trace,
+                    intermediateOutputAllow: opts.intermediateOutputAllow,
+                    onIntermediateOutputItem: opts.onIntermediateOutputItem,
+                    intermediateOutputErrorContext: opts.intermediateOutputErrorContext,
                     workspacePermissions: opts.workspacePermissions,
                     workspacePermissionsBaseDir: opts.workspacePermissionsBaseDir,
                     sessionPermissions: opts.sessionPermissions,
@@ -456,6 +488,9 @@ export async function runDeck(opts) {
                     responsesMode: opts.responsesMode,
                     permissions: permissions.effective,
                     permissionsTrace: permissions.trace,
+                    intermediateOutputAllow: opts.intermediateOutputAllow,
+                    onIntermediateOutputItem: opts.onIntermediateOutputItem,
+                    intermediateOutputErrorContext: opts.intermediateOutputErrorContext,
                     workspacePermissions: opts.workspacePermissions,
                     workspacePermissionsBaseDir: opts.workspacePermissionsBaseDir,
                     sessionPermissions: opts.sessionPermissions,
@@ -501,6 +536,10 @@ export async function runDeck(opts) {
         };
         const runDeadlineMs = deadlineForRun(effectiveGuardrails, opts.runDeadlineMs);
         ensureRunActive(runDeadlineMs, opts.signal);
+        const hasModelParams = Boolean(deck.modelParams?.model || deck.modelParams?.temperature !== undefined);
+        if (hasModelParams) {
+            assertLegacySyntheticResponseToolsRemoved(deck);
+        }
         ensureSchemaPresence(deck, isRoot);
         const resolvedInput = resolveInput({
             deck,
@@ -514,7 +553,7 @@ export async function runDeck(opts) {
             !opts.inOrchestrationWorker &&
             isRoot &&
             !opts.onTool &&
-            Boolean(deck.modelParams?.model || deck.modelParams?.temperature !== undefined);
+            hasModelParams;
         if (useOrchestrationWorker) {
             return await runLlmDeckInWorker({
                 deckPath: deck.path,
@@ -536,6 +575,9 @@ export async function runDeck(opts) {
                 responsesMode: opts.responsesMode,
                 permissions: permissions.effective,
                 permissionsTrace: permissions.trace,
+                intermediateOutputAllow: opts.intermediateOutputAllow,
+                onIntermediateOutputItem: opts.onIntermediateOutputItem,
+                intermediateOutputErrorContext: opts.intermediateOutputErrorContext,
                 workspacePermissions: opts.workspacePermissions,
                 workspacePermissionsBaseDir: opts.workspacePermissionsBaseDir,
                 sessionPermissions: opts.sessionPermissions,
@@ -558,7 +600,7 @@ export async function runDeck(opts) {
                 permissions: permissions.trace,
             });
         }
-        if (deck.modelParams?.model || deck.modelParams?.temperature !== undefined) {
+        if (hasModelParams) {
             return await runLlmDeck({
                 deck,
                 guardrails: effectiveGuardrails,
@@ -579,6 +621,9 @@ export async function runDeck(opts) {
                 responsesMode: opts.responsesMode,
                 permissions: permissions.effective,
                 permissionsTrace: permissions.trace,
+                intermediateOutputAllow: opts.intermediateOutputAllow,
+                onIntermediateOutputItem: opts.onIntermediateOutputItem,
+                intermediateOutputErrorContext: opts.intermediateOutputErrorContext,
                 workspacePermissions: opts.workspacePermissions,
                 workspacePermissionsBaseDir: opts.workspacePermissionsBaseDir,
                 sessionPermissions: opts.sessionPermissions,
@@ -611,6 +656,9 @@ export async function runDeck(opts) {
             responsesMode: opts.responsesMode,
             permissions: permissions.effective,
             permissionsTrace: permissions.trace,
+            intermediateOutputAllow: opts.intermediateOutputAllow,
+            onIntermediateOutputItem: opts.onIntermediateOutputItem,
+            intermediateOutputErrorContext: opts.intermediateOutputErrorContext,
             workspacePermissions: opts.workspacePermissions,
             workspacePermissionsBaseDir: opts.workspacePermissionsBaseDir,
             sessionPermissions: opts.sessionPermissions,
@@ -686,10 +734,75 @@ function resolveContextSchema(deck) {
 function resolveResponseSchema(deck) {
     return deck.responseSchema ?? deck.outputSchema;
 }
+function toResponseTextConfig(deck) {
+    const responseSchema = resolveResponseSchema(deck);
+    if (!responseSchema)
+        return undefined;
+    const schema = toJsonSchema(responseSchema);
+    if (!isStructuredResponseSchema(schema))
+        return undefined;
+    return {
+        format: {
+            type: "json_schema",
+            name: responseSchemaName(deck),
+            schema,
+            strict: true,
+        },
+    };
+}
+function isStructuredResponseSchema(schema) {
+    const type = schema.type;
+    if (typeof type === "string") {
+        return type !== "string";
+    }
+    if (Array.isArray(type)) {
+        return !type.every((entry) => entry === "string");
+    }
+    const properties = schema.properties;
+    if (properties && typeof properties === "object" && !Array.isArray(properties)) {
+        return true;
+    }
+    return false;
+}
+function responseSchemaName(deck) {
+    const raw = deck.label ??
+        path.basename(deck.path, path.extname(deck.path)) ??
+        "gambit_response";
+    const normalized = raw.toLowerCase().replace(/[^a-z0-9_]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 64);
+    return normalized || "gambit_response";
+}
+const REMOVED_LEGACY_RESPONSE_TOOL_NAMES = new Set([
+    GAMBIT_TOOL_RESPOND,
+    GAMBIT_TOOL_END,
+]);
+const LEGACY_RESPONSE_TOOL_MIGRATION_GUIDANCE = [
+    `Legacy synthetic response tools (${Array.from(REMOVED_LEGACY_RESPONSE_TOOL_NAMES).join(", ")}) are removed.`,
+    "Remove `respond`/`allowEnd` from deck metadata and remove any `gambit://respond`, `gambit://end`, `gambit://snippets/respond.md`, or `gambit://snippets/end.md` embeds.",
+    "Return normal assistant output that matches `responseSchema` instead of synthetic completion tools.",
+].join(" ");
+function legacyResponseToolMigrationError(details) {
+    return new Error(`[gambit] ${details} ${LEGACY_RESPONSE_TOOL_MIGRATION_GUIDANCE}`);
+}
+function syntheticContextToolInvocationError(deckPath) {
+    return new Error(`[gambit] Model emitted synthetic context tool for deck ${deckPath}. gambit_context is injected automatically when context input is provided. Do not call gambit_context or gambit_init from the model.`);
+}
+function assertLegacySyntheticResponseToolsRemoved(deck) {
+    if (!deck.respond && !deck.allowEnd)
+        return;
+    const enabled = [];
+    if (deck.respond)
+        enabled.push("respond");
+    if (deck.allowEnd)
+        enabled.push("allowEnd");
+    throw legacyResponseToolMigrationError(`Deck ${deck.path} enables removed synthetic response controls (${enabled.join(", ")}).`);
+}
 function isContextToolName(name) {
     return name === GAMBIT_TOOL_CONTEXT || name === GAMBIT_TOOL_INIT;
 }
 function ensureSchemaPresence(deck, isRoot) {
+    for (const extension of deck.responseItemExtensions ?? []) {
+        assertZodSchema(extension.dataSchema, `responseItemExtensions["${extension.type}"].dataSchema`);
+    }
     if (!isRoot) {
         const contextSchema = resolveContextSchema(deck);
         const responseSchema = resolveResponseSchema(deck);
@@ -861,6 +974,132 @@ function responseItemsFromMessages(messages) {
     }
     return items;
 }
+const CORE_RESPONSE_ITEM_TYPES = new Set([
+    "message",
+    "function_call",
+    "function_call_output",
+    "reasoning",
+]);
+function isCoreResponseItemType(type) {
+    return CORE_RESPONSE_ITEM_TYPES.has(type);
+}
+function isResponseExtensionItem(item) {
+    return item.type.includes(":");
+}
+function canonicalizeJsonValue(value) {
+    if (value === null)
+        return null;
+    if (typeof value === "string" || typeof value === "boolean")
+        return value;
+    if (typeof value === "number") {
+        return Number.isFinite(value) ? value : String(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => canonicalizeJsonValue(entry));
+    }
+    if (value && typeof value === "object") {
+        const record = value;
+        const sortedKeys = Object.keys(record).sort((a, b) => a.localeCompare(b));
+        const out = {};
+        for (const key of sortedKeys) {
+            const next = record[key];
+            if (next === undefined)
+                continue;
+            out[key] = canonicalizeJsonValue(next);
+        }
+        return out;
+    }
+    return String(value);
+}
+function createResponseItemEmissionValidator(deck) {
+    const schemaByType = new Map();
+    for (const extension of deck.responseItemExtensions ?? []) {
+        schemaByType.set(extension.type, extension.dataSchema);
+    }
+    return (item, source) => {
+        const type = item.type;
+        if (isCoreResponseItemType(type))
+            return item;
+        if (!type.includes(":")) {
+            throw new Error(`[gambit] Deck ${deck.path} emitted undeclared non-namespaced response extension item type "${type}" (${source}).`);
+        }
+        const schema = schemaByType.get(type);
+        if (!schema) {
+            throw new Error(`[gambit] Deck ${deck.path} emitted undeclared response extension item type "${type}" (${source}). Declare responseItemExtensions with dataSchema.`);
+        }
+        const asRecord = item;
+        if (!Object.hasOwn(asRecord, "data")) {
+            throw new Error(`[gambit] Deck ${deck.path} emitted extension item "${type}" without data payload (${source}).`);
+        }
+        const data = validateWithSchema(schema, asRecord.data);
+        return {
+            type: type,
+            id: typeof asRecord.id === "string" ? asRecord.id : undefined,
+            data: canonicalizeJsonValue(data),
+        };
+    };
+}
+function validateResponseOutputItems(items, validateItem, source) {
+    return items.map((item, index) => validateItem(item, `${source}[${index}]`));
+}
+function validateResponseEventItems(event, validateItem) {
+    if (event.type === "response.output_item.added" ||
+        event.type === "response.output_item.done") {
+        return {
+            ...event,
+            item: validateItem(event.item, `${event.type}[${event.output_index}]`),
+        };
+    }
+    if (event.type === "response.completed" || event.type === "response.created") {
+        return {
+            ...event,
+            response: {
+                ...event.response,
+                output: validateResponseOutputItems(event.response.output ?? [], validateItem, `${event.type}.response.output`),
+            },
+        };
+    }
+    return event;
+}
+function isSupplementalResponseItem(item) {
+    return item.type === "reasoning" || !isCoreResponseItemType(item.type);
+}
+function supplementalResponseItemSignature(item) {
+    if (item.type === "reasoning") {
+        const content = (item.content ?? []).map((part) => `${part.type}:${part.text}`).join("|");
+        const summary = item.summary.map((part) => `${part.type}:${part.text}`)
+            .join("|");
+        return [
+            "reasoning",
+            item.id ?? "",
+            content,
+            summary,
+            item.encrypted_content ?? "",
+        ].join(":");
+    }
+    if (isResponseExtensionItem(item)) {
+        return [
+            item.type,
+            item.id ?? "",
+            JSON.stringify(item.data),
+        ].join(":");
+    }
+    return "";
+}
+function mergeSupplementalResponseItems(prior, latest) {
+    const out = [];
+    const seen = new Set();
+    for (const item of [...prior, ...latest]) {
+        if (!isSupplementalResponseItem(item))
+            continue;
+        const signature = supplementalResponseItemSignature(item);
+        if (!signature || seen.has(signature))
+            continue;
+        seen.add(signature);
+        out.push(item);
+    }
+    return out;
+}
 function safeJsonArgs(value) {
     if (!value)
         return {};
@@ -882,13 +1121,62 @@ function asToolKind(value, fallback) {
     }
     return fallback;
 }
+function normalizeStreamToolEventType(type) {
+    if (type === "tool.call" || type === "gambit:tool.call")
+        return "tool.call";
+    if (type === "tool.result" || type === "gambit:tool.result") {
+        return "tool.result";
+    }
+    return undefined;
+}
+function isTerminalResponseEventType(type) {
+    return type === "response.completed" || type === "response.failed";
+}
+function normalizeSequenceNumber(value) {
+    if (typeof value !== "number")
+        return undefined;
+    if (!Number.isInteger(value) || value < 0)
+        return undefined;
+    return value;
+}
+function createCanonicalStreamEventController() {
+    let nextSequenceNumber = 0;
+    let terminalStateReached = false;
+    return (streamEvent) => {
+        const type = typeof streamEvent.type === "string" ? streamEvent.type : "";
+        if (!type)
+            return streamEvent;
+        const isResponseEvent = type.startsWith("response.");
+        const isToolEvent = normalizeStreamToolEventType(type) !== undefined;
+        if (!isResponseEvent && !isToolEvent)
+            return streamEvent;
+        if (terminalStateReached)
+            return null;
+        if (!isResponseEvent)
+            return streamEvent;
+        const nextEvent = { ...streamEvent, type };
+        const existingSequenceNumber = normalizeSequenceNumber(streamEvent.sequence_number);
+        if (existingSequenceNumber === undefined) {
+            nextSequenceNumber += 1;
+            nextEvent.sequence_number = nextSequenceNumber;
+        }
+        else {
+            nextSequenceNumber = Math.max(nextSequenceNumber, existingSequenceNumber);
+        }
+        if (isTerminalResponseEventType(type)) {
+            terminalStateReached = true;
+        }
+        return nextEvent;
+    };
+}
 function projectStreamToolTraceEvents(input) {
     if (!input.trace)
         return;
-    const type = typeof input.streamEvent.type === "string"
+    const rawType = typeof input.streamEvent.type === "string"
         ? input.streamEvent.type
         : "";
-    if (type !== "tool.call" && type !== "tool.result")
+    const type = normalizeStreamToolEventType(rawType);
+    if (!type)
         return;
     const actionCallId = typeof input.streamEvent.actionCallId === "string"
         ? input.streamEvent.actionCallId
@@ -962,6 +1250,682 @@ function traceOpenResponsesStreamEvent(input) {
     });
     return true;
 }
+function createIntermediateOutputDisallowedError(input) {
+    const action = typeof input.context?.actionName === "string" &&
+        input.context.actionName.trim().length > 0
+        ? `action "${input.context.actionName.trim()}"`
+        : "action";
+    const deckSuffix = typeof input.context?.parentDeckPath === "string" &&
+        input.context.parentDeckPath.trim().length > 0
+        ? ` in ${input.context.parentDeckPath.trim()}`
+        : "";
+    const error = new Error(`[gambit] ${action}${deckSuffix} disallows intermediate output emission (${input.source}). Set action.intermediateOutput.emit = "allow" to opt in.`);
+    error.code = INTERMEDIATE_OUTPUT_DISALLOWED_CODE;
+    return error;
+}
+function createIntermediateChildResponseEmitter(input) {
+    const responseId = `${input.actionCallId}:intermediate`;
+    const canonicalizeStreamEvent = createCanonicalStreamEventController();
+    const emittedItems = [];
+    let nextOutputIndex = 0;
+    let created = false;
+    let terminal = false;
+    const emitStreamEvent = (event) => {
+        const canonical = canonicalizeStreamEvent(event);
+        if (!canonical)
+            return;
+        traceOpenResponsesStreamEvent({
+            streamEvent: canonical,
+            runId: input.runId,
+            actionCallId: input.actionCallId,
+            deckPath: input.deckPath,
+            parentActionCallId: input.parentActionCallId,
+            trace: input.trace,
+        });
+    };
+    const ensureCreated = () => {
+        if (created)
+            return;
+        created = true;
+        emitStreamEvent({
+            type: "response.created",
+            response: {
+                id: responseId,
+                object: "response",
+                status: "in_progress",
+                output: [],
+            },
+        });
+    };
+    return {
+        emitOutputItem: (item, source) => {
+            input.ensureActive();
+            if (input.allowEmission === false) {
+                throw createIntermediateOutputDisallowedError({
+                    source,
+                    context: input.errorContext,
+                });
+            }
+            if (terminal)
+                return;
+            const validated = input.validateItem(item, source);
+            ensureCreated();
+            const outputIndex = nextOutputIndex++;
+            emittedItems.push(validated);
+            emitStreamEvent({
+                type: "response.output_item.added",
+                response_id: responseId,
+                output_index: outputIndex,
+                item: validated,
+            });
+            emitStreamEvent({
+                type: "response.output_item.done",
+                response_id: responseId,
+                output_index: outputIndex,
+                item: validated,
+            });
+            input.onEmit?.({
+                responseId,
+                actionCallId: input.actionCallId,
+                parentActionCallId: input.parentActionCallId,
+                deckPath: input.deckPath,
+                outputIndex,
+                item: validated,
+            });
+        },
+        complete: () => {
+            input.ensureActive();
+            if (terminal || !created) {
+                terminal = true;
+                return;
+            }
+            emitStreamEvent({
+                type: "response.completed",
+                response: {
+                    id: responseId,
+                    object: "response",
+                    status: "completed",
+                    output: emittedItems,
+                },
+            });
+            terminal = true;
+        },
+        fail: (err) => {
+            if (terminal || !created) {
+                terminal = true;
+                return;
+            }
+            const code = typeof err?.code === "string"
+                ? err.code
+                : undefined;
+            const message = err instanceof Error ? err.message : String(err);
+            emitStreamEvent({
+                type: "response.failed",
+                response_id: responseId,
+                error: {
+                    ...(code ? { code } : {}),
+                    message,
+                },
+            });
+            terminal = true;
+        },
+    };
+}
+function parseIntermediateOutputEmissionFromTraceEvent(input) {
+    if (input.event.type !== "response.output_item.done")
+        return undefined;
+    const eventRecord = input.event;
+    const responseId = typeof eventRecord.response_id === "string"
+        ? eventRecord.response_id
+        : undefined;
+    if (!responseId || !responseId.endsWith(":intermediate"))
+        return undefined;
+    const outputIndex = eventRecord.output_index;
+    if (!Number.isInteger(outputIndex) || Number(outputIndex) < 0) {
+        return undefined;
+    }
+    const item = eventRecord.item;
+    if (!item || typeof item !== "object" || Array.isArray(item)) {
+        return undefined;
+    }
+    const gambitMeta = eventRecord._gambit && typeof eventRecord._gambit ===
+        "object" &&
+        !Array.isArray(eventRecord._gambit)
+        ? eventRecord._gambit
+        : {};
+    const actionCallId = typeof gambitMeta.action_call_id === "string"
+        ? gambitMeta.action_call_id
+        : undefined;
+    if (!actionCallId)
+        return undefined;
+    const parentActionCallId = typeof gambitMeta.parent_action_call_id ===
+        "string"
+        ? gambitMeta.parent_action_call_id
+        : undefined;
+    if (input.expectedParentActionCallId !== undefined &&
+        parentActionCallId !== input.expectedParentActionCallId) {
+        return undefined;
+    }
+    const deckPath = typeof gambitMeta.deck_path === "string"
+        ? gambitMeta.deck_path
+        : "";
+    if (!deckPath)
+        return undefined;
+    return {
+        responseId,
+        actionCallId,
+        parentActionCallId,
+        deckPath,
+        outputIndex: Number(outputIndex),
+        item: item,
+    };
+}
+function cloneAsyncActionTerminalResult(input) {
+    return {
+        state: input.state,
+        status: input.status,
+        payload: input.payload,
+        message: input.message,
+        code: input.code,
+        meta: input.meta ? { ...input.meta } : undefined,
+    };
+}
+function cloneIntermediateEmission(emission) {
+    return {
+        responseId: emission.responseId,
+        actionCallId: emission.actionCallId,
+        parentActionCallId: emission.parentActionCallId,
+        deckPath: emission.deckPath,
+        outputIndex: emission.outputIndex,
+        item: emission.item,
+    };
+}
+function cloneAsyncActionJobEvent(event) {
+    if (event.type === "intermediate_output") {
+        return {
+            cursor: event.cursor,
+            type: "intermediate_output",
+            emission: cloneIntermediateEmission(event.emission),
+        };
+    }
+    return {
+        cursor: event.cursor,
+        type: "terminal",
+        terminal: cloneAsyncActionTerminalResult(event.terminal),
+    };
+}
+function parsePersistedAsyncActionJobs(state) {
+    const meta = state?.meta;
+    const raw = meta?.[ASYNC_ACTION_JOBS_META_KEY];
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return undefined;
+    const asRecord = raw;
+    const version = Number.isInteger(asRecord.version)
+        ? Number(asRecord.version)
+        : undefined;
+    if (version !== ASYNC_ACTION_JOBS_META_VERSION)
+        return undefined;
+    const rawJobs = asRecord.jobs;
+    if (!Array.isArray(rawJobs))
+        return undefined;
+    const jobs = [];
+    for (const rawJob of rawJobs) {
+        if (!rawJob || typeof rawJob !== "object" || Array.isArray(rawJob)) {
+            continue;
+        }
+        const rec = rawJob;
+        const jobId = typeof rec.jobId === "string" ? rec.jobId : "";
+        const actionName = typeof rec.actionName === "string" ? rec.actionName : "";
+        const actionPath = typeof rec.actionPath === "string" ? rec.actionPath : "";
+        const stateValue = typeof rec.state === "string" ? rec.state : "";
+        if (!jobId || !actionName || !actionPath)
+            continue;
+        if (stateValue !== "running" && stateValue !== "completed" &&
+            stateValue !== "failed" && stateValue !== "canceled") {
+            continue;
+        }
+        const parsedState = stateValue;
+        const cursorBase = Number.isInteger(rec.cursorBase)
+            ? Math.max(0, Number(rec.cursorBase))
+            : 0;
+        const nextCursor = Number.isInteger(rec.nextCursor)
+            ? Math.max(cursorBase, Number(rec.nextCursor))
+            : cursorBase;
+        const expectedCursor = Number.isInteger(rec.expectedCursor)
+            ? Math.max(cursorBase, Math.min(nextCursor, Number(rec.expectedCursor)))
+            : cursorBase;
+        const rawEvents = Array.isArray(rec.events) ? rec.events : [];
+        const events = [];
+        for (const rawEvent of rawEvents) {
+            if (!rawEvent || typeof rawEvent !== "object" || Array.isArray(rawEvent)) {
+                continue;
+            }
+            const eventRec = rawEvent;
+            const cursor = Number.isInteger(eventRec.cursor)
+                ? Number(eventRec.cursor)
+                : NaN;
+            if (!Number.isInteger(cursor) || cursor < cursorBase || cursor >= nextCursor) {
+                continue;
+            }
+            const eventType = typeof eventRec.type === "string" ? eventRec.type : "";
+            if (eventType === "intermediate_output") {
+                const emission = eventRec.emission;
+                if (!emission || typeof emission !== "object" || Array.isArray(emission)) {
+                    continue;
+                }
+                const emissionRec = emission;
+                const outputIndex = Number.isInteger(emissionRec.outputIndex)
+                    ? Number(emissionRec.outputIndex)
+                    : NaN;
+                if (!Number.isInteger(outputIndex) || outputIndex < 0)
+                    continue;
+                const responseId = typeof emissionRec.responseId === "string"
+                    ? emissionRec.responseId
+                    : "";
+                const actionCallId = typeof emissionRec.actionCallId === "string"
+                    ? emissionRec.actionCallId
+                    : "";
+                const deckPath = typeof emissionRec.deckPath === "string"
+                    ? emissionRec.deckPath
+                    : "";
+                const item = emissionRec.item;
+                if (!responseId || !actionCallId || !deckPath || !item)
+                    continue;
+                events.push({
+                    cursor,
+                    type: "intermediate_output",
+                    emission: {
+                        responseId,
+                        actionCallId,
+                        parentActionCallId: typeof emissionRec.parentActionCallId === "string"
+                            ? emissionRec.parentActionCallId
+                            : undefined,
+                        deckPath,
+                        outputIndex,
+                        item: item,
+                    },
+                });
+                continue;
+            }
+            if (eventType === "terminal") {
+                const terminal = eventRec.terminal;
+                if (!terminal || typeof terminal !== "object" || Array.isArray(terminal)) {
+                    continue;
+                }
+                const terminalRec = terminal;
+                const terminalState = terminalRec.state;
+                if (terminalState !== "completed" && terminalState !== "failed" &&
+                    terminalState !== "canceled") {
+                    continue;
+                }
+                events.push({
+                    cursor,
+                    type: "terminal",
+                    terminal: {
+                        state: terminalState,
+                        status: typeof terminalRec.status === "number"
+                            ? terminalRec.status
+                            : undefined,
+                        payload: terminalRec.payload,
+                        message: typeof terminalRec.message === "string"
+                            ? terminalRec.message
+                            : undefined,
+                        code: typeof terminalRec.code === "string"
+                            ? terminalRec.code
+                            : undefined,
+                        meta: terminalRec.meta && typeof terminalRec.meta === "object" &&
+                            !Array.isArray(terminalRec.meta)
+                            ? terminalRec.meta
+                            : undefined,
+                    },
+                });
+            }
+        }
+        events.sort((a, b) => a.cursor - b.cursor);
+        const terminal = rec.terminal && typeof rec.terminal === "object" &&
+            !Array.isArray(rec.terminal)
+            ? (() => {
+                const terminalRec = rec.terminal;
+                const terminalState = terminalRec.state;
+                if (terminalState !== "completed" && terminalState !== "failed" &&
+                    terminalState !== "canceled") {
+                    return undefined;
+                }
+                return {
+                    state: terminalState,
+                    status: typeof terminalRec.status === "number"
+                        ? terminalRec.status
+                        : undefined,
+                    payload: terminalRec.payload,
+                    message: typeof terminalRec.message === "string"
+                        ? terminalRec.message
+                        : undefined,
+                    code: typeof terminalRec.code === "string"
+                        ? terminalRec.code
+                        : undefined,
+                    meta: terminalRec.meta && typeof terminalRec.meta === "object" &&
+                        !Array.isArray(terminalRec.meta)
+                        ? terminalRec.meta
+                        : undefined,
+                };
+            })()
+            : undefined;
+        jobs.push({
+            jobId,
+            actionName,
+            actionPath,
+            state: parsedState,
+            cursorBase,
+            nextCursor,
+            expectedCursor,
+            events,
+            terminal,
+        });
+    }
+    return { version, jobs };
+}
+function createAsyncActionJobController(input) {
+    const jobs = new Map();
+    const notifyChange = () => input.onChange?.();
+    const notifyWaiters = (record) => {
+        if (record.waiters.size === 0)
+            return;
+        for (const waiter of record.waiters) {
+            waiter();
+        }
+        record.waiters.clear();
+    };
+    const appendEvent = (record, event) => {
+        const withCursor = {
+            ...event,
+            cursor: record.nextCursor,
+        };
+        record.events.push(withCursor);
+        record.nextCursor += 1;
+        while (record.events.length > ASYNC_ACTION_JOB_MAX_EVENTS) {
+            record.events.shift();
+            record.cursorBase += 1;
+        }
+    };
+    const completeRecord = (record, terminal) => {
+        if (record.state !== "running")
+            return;
+        record.state = terminal.state;
+        record.terminal = cloneAsyncActionTerminalResult(terminal);
+        appendEvent(record, {
+            type: "terminal",
+            terminal: cloneAsyncActionTerminalResult(terminal),
+        });
+        notifyWaiters(record);
+        notifyChange();
+    };
+    const persisted = parsePersistedAsyncActionJobs(input.state);
+    if (persisted) {
+        let normalizedPersisted = false;
+        for (const entry of persisted.jobs) {
+            const record = {
+                ...entry,
+                events: entry.events.map((event) => cloneAsyncActionJobEvent(event)),
+                terminal: entry.terminal
+                    ? cloneAsyncActionTerminalResult(entry.terminal)
+                    : undefined,
+                waiters: new Set(),
+            };
+            if (record.expectedCursor < record.cursorBase) {
+                record.expectedCursor = record.cursorBase;
+                normalizedPersisted = true;
+            }
+            if (record.expectedCursor > record.nextCursor) {
+                record.expectedCursor = record.nextCursor;
+                normalizedPersisted = true;
+            }
+            if (record.state === "running") {
+                normalizedPersisted = true;
+                completeRecord(record, {
+                    state: "canceled",
+                    status: 499,
+                    code: ASYNC_ACTION_JOB_INTERRUPTED_CODE,
+                    message: "Async action job was interrupted before the run resumed.",
+                });
+            }
+            else if (!record.terminal) {
+                const terminalEvent = [...record.events].reverse().find((event) => event.type === "terminal");
+                if (terminalEvent?.type === "terminal") {
+                    record.terminal = cloneAsyncActionTerminalResult(terminalEvent.terminal);
+                    normalizedPersisted = true;
+                }
+            }
+            jobs.set(record.jobId, record);
+        }
+        if (normalizedPersisted) {
+            notifyChange();
+        }
+    }
+    const waitForJobChange = async (record, waitMs, signal) => {
+        if (waitMs <= 0)
+            return;
+        await new Promise((resolve) => {
+            const timeoutId = setTimeout(() => {
+                cleanup();
+                resolve();
+            }, waitMs);
+            const onAbort = () => {
+                cleanup();
+                resolve();
+            };
+            const waiter = () => {
+                cleanup();
+                resolve();
+            };
+            const cleanup = () => {
+                clearTimeout(timeoutId);
+                record.waiters.delete(waiter);
+                if (signal)
+                    signal.removeEventListener("abort", onAbort);
+            };
+            record.waiters.add(waiter);
+            if (signal)
+                signal.addEventListener("abort", onAbort, { once: true });
+            if (signal?.aborted) {
+                cleanup();
+                resolve();
+            }
+        });
+    };
+    return {
+        hasConfiguredAsyncActions: input.hasConfiguredAsyncActions,
+        hasLiveJobs: () => Array.from(jobs.values()).some((job) => job.state === "running"),
+        startJob: ({ actionName, actionPath }) => {
+            const jobId = randomId("job");
+            const record = {
+                jobId,
+                actionName,
+                actionPath,
+                state: "running",
+                cursorBase: 0,
+                nextCursor: 0,
+                expectedCursor: 0,
+                events: [],
+                waiters: new Set(),
+            };
+            jobs.set(jobId, record);
+            notifyChange();
+            return {
+                handle: {
+                    jobId,
+                    actionName,
+                    state: "running",
+                    cursor: {
+                        min: record.cursorBase,
+                        next: record.nextCursor,
+                    },
+                },
+                appendIntermediateOutput: (emission) => {
+                    if (record.state !== "running")
+                        return;
+                    appendEvent(record, {
+                        type: "intermediate_output",
+                        emission: cloneIntermediateEmission(emission),
+                    });
+                    notifyWaiters(record);
+                    notifyChange();
+                },
+                complete: (terminalResult) => {
+                    completeRecord(record, {
+                        state: "completed",
+                        status: terminalResult.status,
+                        payload: terminalResult.payload,
+                        message: terminalResult.message,
+                        code: terminalResult.code,
+                        meta: terminalResult.meta,
+                    });
+                },
+                fail: (terminalResult) => {
+                    completeRecord(record, {
+                        state: terminalResult.state,
+                        status: terminalResult.status,
+                        payload: terminalResult.payload,
+                        message: terminalResult.message,
+                        code: terminalResult.code,
+                        meta: terminalResult.meta,
+                    });
+                },
+                bindLiveRun: (runPromise, controller) => {
+                    record.controller = controller;
+                    record.runPromise = runPromise.finally(() => {
+                        record.runPromise = undefined;
+                        record.controller = undefined;
+                    });
+                },
+            };
+        },
+        consume: async (consumeInput) => {
+            ensureRunActive(consumeInput.runDeadlineMs, consumeInput.signal);
+            const record = jobs.get(consumeInput.jobId);
+            if (!record) {
+                return {
+                    ok: false,
+                    status: 404,
+                    code: "async_job_not_found",
+                    message: `Unknown async action job: ${consumeInput.jobId}`,
+                };
+            }
+            let cursor = consumeInput.cursor;
+            if (!Number.isInteger(cursor) || cursor < 0) {
+                return {
+                    ok: false,
+                    status: 400,
+                    code: "invalid_cursor",
+                    message: "cursor must be a non-negative integer",
+                };
+            }
+            if (cursor < record.cursorBase) {
+                return {
+                    ok: false,
+                    status: 409,
+                    code: "cursor_expired",
+                    message: `cursor ${cursor} is behind retained minimum cursor ${record.cursorBase}`,
+                    payload: { minCursor: record.cursorBase },
+                };
+            }
+            if (cursor > record.nextCursor) {
+                return {
+                    ok: false,
+                    status: 400,
+                    code: "invalid_cursor",
+                    message: `cursor ${cursor} is beyond current cursor ${record.nextCursor}`,
+                    payload: { maxCursor: record.nextCursor },
+                };
+            }
+            if (cursor !== record.expectedCursor) {
+                return {
+                    ok: false,
+                    status: 409,
+                    code: "cursor_mismatch",
+                    message: `cursor ${cursor} does not match expected cursor ${record.expectedCursor}`,
+                    payload: { expectedCursor: record.expectedCursor },
+                };
+            }
+            const boundedWaitMs = Math.min(ASYNC_ACTION_JOB_MAX_WAIT_MS, Math.max(0, consumeInput.waitMs));
+            const remainingMs = Math.max(0, Math.floor(consumeInput.runDeadlineMs - performance.now()));
+            const waitMs = Math.min(boundedWaitMs, remainingMs);
+            if (waitMs > 0 &&
+                record.state === "running" &&
+                cursor >= record.nextCursor) {
+                await waitForJobChange(record, waitMs, consumeInput.signal);
+            }
+            ensureRunActive(consumeInput.runDeadlineMs, consumeInput.signal);
+            cursor = consumeInput.cursor;
+            if (cursor < record.cursorBase) {
+                return {
+                    ok: false,
+                    status: 409,
+                    code: "cursor_expired",
+                    message: `cursor ${cursor} is behind retained minimum cursor ${record.cursorBase}`,
+                    payload: { minCursor: record.cursorBase },
+                };
+            }
+            const startIndex = Math.max(0, cursor - record.cursorBase);
+            const events = record.events.slice(startIndex, startIndex + consumeInput.limit).map((event) => cloneAsyncActionJobEvent(event));
+            const nextCursor = cursor + events.length;
+            if (record.expectedCursor !== nextCursor) {
+                record.expectedCursor = nextCursor;
+                notifyChange();
+            }
+            return {
+                ok: true,
+                payload: {
+                    jobId: record.jobId,
+                    actionName: record.actionName,
+                    state: record.state,
+                    cursor: {
+                        requested: consumeInput.cursor,
+                        min: record.cursorBase,
+                        next: nextCursor,
+                        expected: record.expectedCursor,
+                    },
+                    events,
+                    terminal: record.terminal
+                        ? cloneAsyncActionTerminalResult(record.terminal)
+                        : undefined,
+                },
+            };
+        },
+        snapshot: () => {
+            if (jobs.size === 0)
+                return undefined;
+            return {
+                version: ASYNC_ACTION_JOBS_META_VERSION,
+                jobs: Array.from(jobs.values()).map((job) => ({
+                    jobId: job.jobId,
+                    actionName: job.actionName,
+                    actionPath: job.actionPath,
+                    state: job.state,
+                    cursorBase: job.cursorBase,
+                    nextCursor: job.nextCursor,
+                    expectedCursor: job.expectedCursor,
+                    events: job.events.map((event) => cloneAsyncActionJobEvent(event)),
+                    terminal: job.terminal
+                        ? cloneAsyncActionTerminalResult(job.terminal)
+                        : undefined,
+                })),
+            };
+        },
+        cancelLiveJobs: ({ message, code }) => {
+            for (const record of jobs.values()) {
+                if (record.state !== "running")
+                    continue;
+                completeRecord(record, {
+                    state: "canceled",
+                    status: 499,
+                    code,
+                    message,
+                });
+                record.controller?.abort();
+            }
+        },
+    };
+}
 function mapResponseOutput(output) {
     const toolCalls = [];
     const textParts = [];
@@ -1015,7 +1979,22 @@ function validateInput(deck, input, isRoot, allowRootStringInput) {
 function validateOutput(deck, output, isRoot) {
     const responseSchema = resolveResponseSchema(deck);
     if (responseSchema) {
-        return validateWithSchema(responseSchema, output);
+        try {
+            return validateWithSchema(responseSchema, output);
+        }
+        catch (directErr) {
+            if (typeof output !== "string")
+                throw directErr;
+            try {
+                const parsed = JSON.parse(output);
+                return validateWithSchema(responseSchema, parsed);
+            }
+            catch (parsedErr) {
+                if (parsedErr instanceof SyntaxError)
+                    throw directErr;
+                throw parsedErr;
+            }
+        }
     }
     if (isRoot) {
         if (typeof output === "string")
@@ -1045,6 +2024,9 @@ async function runComputeDeck(ctx) {
             responsesMode: ctx.responsesMode,
             permissions: ctx.permissions,
             permissionsTrace: ctx.permissionsTrace,
+            intermediateOutputAllow: ctx.intermediateOutputAllow,
+            onIntermediateOutputItem: ctx.onIntermediateOutputItem,
+            intermediateOutputErrorContext: ctx.intermediateOutputErrorContext,
             workspacePermissions: ctx.workspacePermissions,
             workspacePermissionsBaseDir: ctx.workspacePermissionsBaseDir,
             sessionPermissions: ctx.sessionPermissions,
@@ -1417,14 +2399,30 @@ function collectLocalImportGraph(entryPath) {
     }
     return visited;
 }
-const WORKER_ENTRY_PATHS = [
-    "./runtime_worker.ts",
-    "./runtime_orchestration_worker.ts",
-].map((relative) => path.fromFileUrl(new URL(relative, globalThis[Symbol.for("import-meta-ponyfill-esmodule")](import.meta).url)));
-const BUILTIN_SCHEMAS_DIR = path.resolve(path.dirname(path.fromFileUrl(globalThis[Symbol.for("import-meta-ponyfill-esmodule")](import.meta).url)), "../schemas");
-const BUILTIN_SNIPPETS_DIR = path.resolve(path.dirname(path.fromFileUrl(globalThis[Symbol.for("import-meta-ponyfill-esmodule")](import.meta).url)), "../snippets");
+const moduleBaseFilePath = (() => {
+    try {
+        return path.fromFileUrl(globalThis[Symbol.for("import-meta-ponyfill-esmodule")](import.meta).url);
+    }
+    catch {
+        return undefined;
+    }
+})();
+const WORKER_ENTRY_PATHS = moduleBaseFilePath
+    ? [
+        "./runtime_worker.ts",
+        "./runtime_orchestration_worker.ts",
+    ].map((relative) => path.fromFileUrl(new URL(relative, globalThis[Symbol.for("import-meta-ponyfill-esmodule")](import.meta).url)))
+    : [];
+const BUILTIN_SCHEMAS_DIR = moduleBaseFilePath
+    ? path.resolve(path.dirname(moduleBaseFilePath), "../schemas")
+    : undefined;
+const BUILTIN_SNIPPETS_DIR = moduleBaseFilePath
+    ? path.resolve(path.dirname(moduleBaseFilePath), "../snippets")
+    : undefined;
 let builtinSchemaBootstrapCache;
 function builtinSchemaBootstrapReads() {
+    if (!BUILTIN_SCHEMAS_DIR)
+        return [];
     if (builtinSchemaBootstrapCache)
         return builtinSchemaBootstrapCache;
     const schemaModules = [];
@@ -1457,6 +2455,8 @@ function builtinSchemaBootstrapReads() {
 }
 let builtinSnippetBootstrapCache;
 function builtinSnippetBootstrapReads() {
+    if (!BUILTIN_SNIPPETS_DIR)
+        return [];
     if (builtinSnippetBootstrapCache)
         return builtinSnippetBootstrapCache;
     const snippetFiles = [];
@@ -1499,6 +2499,10 @@ let trustedWorkerBootstrapCache;
 function trustedWorkerBootstrapReads() {
     if (trustedWorkerBootstrapCache)
         return trustedWorkerBootstrapCache;
+    if (!moduleBaseFilePath) {
+        trustedWorkerBootstrapCache = [];
+        return trustedWorkerBootstrapCache;
+    }
     const definitionsPath = path.fromFileUrl(new URL("./definitions.ts", globalThis[Symbol.for("import-meta-ponyfill-esmodule")](import.meta).url));
     const modPath = path.fromFileUrl(new URL("../mod.ts", globalThis[Symbol.for("import-meta-ponyfill-esmodule")](import.meta).url));
     trustedWorkerBootstrapCache = Array.from(new Set([
@@ -1688,6 +2692,7 @@ async function runLlmDeckInWorker(ctx) {
     const bridgeSession = randomId("bridge");
     const completionNonce = randomId("done");
     const worker = createWorkerSandboxBridge(new URL("./runtime_orchestration_worker.ts", globalThis[Symbol.for("import-meta-ponyfill-esmodule")](import.meta).url).href, buildWorkerPermissions(ctx.permissions, ctx.deckPath));
+    const modelRequestControllers = new Map();
     let settled = false;
     const clearAndTerminate = () => {
         try {
@@ -1739,6 +2744,15 @@ async function runLlmDeckInWorker(ctx) {
                 return;
             }
             if (msg.type === "trace.event") {
+                const emission = ctx.onIntermediateOutputItem
+                    ? parseIntermediateOutputEmissionFromTraceEvent({
+                        event: msg.event,
+                        expectedParentActionCallId: ctx.parentActionCallId,
+                    })
+                    : undefined;
+                if (emission) {
+                    ctx.onIntermediateOutputItem?.(emission);
+                }
                 ctx.trace?.(msg.event);
                 return;
             }
@@ -1752,10 +2766,12 @@ async function runLlmDeckInWorker(ctx) {
             }
             if (msg.type === "model.chat.request") {
                 (async () => {
+                    const controller = new AbortController();
+                    modelRequestControllers.set(msg.requestId, controller);
                     try {
                         const result = await ctx.modelProvider.chat({
                             ...msg.input,
-                            signal: ctx.signal,
+                            signal: mergeAbortSignals(ctx.signal, controller.signal),
                             onStreamText: (chunk) => {
                                 worker.postMessage({
                                     type: "model.chat.stream",
@@ -1782,18 +2798,23 @@ async function runLlmDeckInWorker(ctx) {
                             },
                         });
                     }
+                    finally {
+                        modelRequestControllers.delete(msg.requestId);
+                    }
                 })();
                 return;
             }
             if (msg.type === "model.responses.request") {
                 (async () => {
+                    const controller = new AbortController();
+                    modelRequestControllers.set(msg.requestId, controller);
                     try {
                         if (!ctx.modelProvider.responses) {
                             throw new Error("Responses API unavailable for current model provider");
                         }
                         const result = await ctx.modelProvider.responses({
                             ...msg.input,
-                            signal: ctx.signal,
+                            signal: mergeAbortSignals(ctx.signal, controller.signal),
                             onStreamEvent: (streamEvent) => {
                                 worker.postMessage({
                                     type: "model.responses.event",
@@ -1820,9 +2841,16 @@ async function runLlmDeckInWorker(ctx) {
                             },
                         });
                     }
+                    finally {
+                        modelRequestControllers.delete(msg.requestId);
+                    }
                 })();
                 return;
             }
+            if (msg.type === "model.request.cancel") {
+                modelRequestControllers.get(msg.requestId)?.abort();
+                return;
+            }
             if (msg.type === "model.resolveModel.request") {
                 (async () => {
                     try {
@@ -1893,6 +2921,8 @@ async function runLlmDeckInWorker(ctx) {
                 state: ctx.state,
                 responsesMode: ctx.responsesMode,
                 allowRootStringInput: ctx.allowRootStringInput,
+                intermediateOutputAllow: ctx.intermediateOutputAllow,
+                intermediateOutputErrorContext: ctx.intermediateOutputErrorContext,
                 runDeadlineMs: ctx.runDeadlineMs,
             },
             permissionCeiling: toWirePermissionSet(ctx.permissions),
@@ -1901,6 +2931,9 @@ async function runLlmDeckInWorker(ctx) {
         return await outcome;
     }
     finally {
+        for (const controller of modelRequestControllers.values()) {
+            controller.abort();
+        }
         if (timeoutId !== undefined)
             clearTimeout(timeoutId);
         clearAndTerminate();
@@ -1925,6 +2958,18 @@ async function runComputeDeckInWorker(ctx) {
     let timeoutId;
     const activeSpawnRequests = new Set();
     let currentState = ctx.state;
+    const intermediateEmitter = createIntermediateChildResponseEmitter({
+        runId,
+        actionCallId,
+        deckPath: ctx.deckPath,
+        parentActionCallId: ctx.parentActionCallId,
+        trace: ctx.trace,
+        validateItem: (item) => item,
+        ensureActive: () => ensureRunActive(ctx.runDeadlineMs, ctx.signal),
+        allowEmission: ctx.intermediateOutputAllow,
+        errorContext: ctx.intermediateOutputErrorContext,
+        onEmit: ctx.onIntermediateOutputItem,
+    });
     const outcome = new Promise((resolve, reject) => {
         const finishResolve = (value) => {
             if (settled)
@@ -2038,6 +3083,9 @@ async function runComputeDeckInWorker(ctx) {
                             responsesMode: ctx.responsesMode,
                             initialUserMessage: req.payload.initialUserMessage,
                             inputProvided: true,
+                            intermediateOutputAllow: req.payload.intermediateOutputAllow,
+                            onIntermediateOutputItem: ctx.onIntermediateOutputItem,
+                            intermediateOutputErrorContext: req.payload.intermediateOutputErrorContext,
                             parentPermissions: bridgedParent,
                             workspacePermissions: req.payload.workspacePermissions,
                             workspacePermissionsBaseDir: req.payload.workspacePermissionsBaseDir,
@@ -2082,12 +3130,34 @@ async function runComputeDeckInWorker(ctx) {
                 ctx.onStateUpdate?.(nextState);
                 return;
             }
+            if (type === "response.item") {
+                const item = msg.item;
+                if (!item || typeof item !== "object")
+                    return;
+                try {
+                    intermediateEmitter.emitOutputItem(item, "worker.emitOutputItem");
+                }
+                catch (err) {
+                    intermediateEmitter.fail(err);
+                    finishReject(err);
+                    clearAndTerminate();
+                }
+                return;
+            }
             if (type === "run.result") {
                 if (msg.completionNonce !==
                     completionNonce) {
                     logger.warn(`[gambit] rejected compute-worker run.result with invalid completion nonce`);
                     return;
                 }
+                try {
+                    intermediateEmitter.complete();
+                }
+                catch (err) {
+                    intermediateEmitter.fail(err);
+                    finishReject(err);
+                    return;
+                }
                 finishResolve(msg.result);
                 return;
             }
@@ -2097,7 +3167,9 @@ async function runComputeDeckInWorker(ctx) {
                     logger.warn(`[gambit] rejected compute-worker run.error with invalid completion nonce`);
                     return;
                 }
-                finishReject(normalizeWorkerError(msg.error));
+                const normalizedError = normalizeWorkerError(msg.error);
+                intermediateEmitter.fail(normalizedError);
+                finishReject(normalizedError);
             }
         });
     });
@@ -2114,6 +3186,8 @@ async function runComputeDeckInWorker(ctx) {
             initialUserMessage: ctx.initialUserMessage,
             depth: ctx.depth,
             parentActionCallId: ctx.parentActionCallId,
+            intermediateOutputAllow: ctx.intermediateOutputAllow,
+            intermediateOutputErrorContext: ctx.intermediateOutputErrorContext,
             permissions: toWirePermissionSet(ctx.permissions),
             workspacePermissions: ctx.workspacePermissions,
             workspacePermissionsBaseDir: ctx.workspacePermissionsBaseDir,
@@ -2136,6 +3210,7 @@ async function runComputeDeckInWorker(ctx) {
 async function runComputeDeckInProcess(ctx) {
     const { deck, runId } = ctx;
     const actionCallId = randomId("action");
+    const validateResponseItemEmission = createResponseItemEmissionValidator(deck);
     let computeState = ctx.state
         ? {
             ...ctx.state,
@@ -2171,6 +3246,18 @@ async function runComputeDeckInProcess(ctx) {
                 : undefined,
         });
     };
+    const intermediateEmitter = createIntermediateChildResponseEmitter({
+        runId,
+        actionCallId,
+        deckPath: deck.path,
+        parentActionCallId: ctx.parentActionCallId,
+        trace: ctx.trace,
+        validateItem: validateResponseItemEmission,
+        ensureActive: () => ensureRunActive(ctx.runDeadlineMs, ctx.signal),
+        allowEmission: ctx.intermediateOutputAllow,
+        errorContext: ctx.intermediateOutputErrorContext,
+        onEmit: ctx.onIntermediateOutputItem,
+    });
     const execContext = {
         runId,
         actionCallId,
@@ -2213,6 +3300,10 @@ async function runComputeDeckInProcess(ctx) {
             state.messageRefs = refs;
             publishComputeState();
         },
+        emitOutputItem: (item) => {
+            intermediateEmitter.emitOutputItem(item, "executionContext.emitOutputItem");
+            return Promise.resolve();
+        },
         label: deck.label,
         log: (entry) => {
             if (!ctx.trace)
@@ -2281,6 +3372,9 @@ async function runComputeDeckInProcess(ctx) {
                 responsesMode: ctx.responsesMode,
                 initialUserMessage: childInitialUserMessage,
                 inputProvided: true,
+                intermediateOutputAllow: ctx.intermediateOutputAllow,
+                onIntermediateOutputItem: ctx.onIntermediateOutputItem,
+                intermediateOutputErrorContext: ctx.intermediateOutputErrorContext,
                 parentPermissions: ctx.permissions,
                 workspacePermissions: ctx.workspacePermissions,
                 workspacePermissionsBaseDir: ctx.workspacePermissionsBaseDir,
@@ -2297,18 +3391,40 @@ async function runComputeDeckInProcess(ctx) {
         },
         return: (payload) => Promise.resolve(payload),
     };
-    ensureRunActive(ctx.runDeadlineMs, ctx.signal);
-    const raw = await deck.executor(execContext);
-    ensureRunActive(ctx.runDeadlineMs, ctx.signal);
-    return validateOutput(deck, raw, ctx.depth === 0);
+    try {
+        ensureRunActive(ctx.runDeadlineMs, ctx.signal);
+        const raw = await deck.executor(execContext);
+        ensureRunActive(ctx.runDeadlineMs, ctx.signal);
+        const validated = validateOutput(deck, raw, ctx.depth === 0);
+        intermediateEmitter.complete();
+        return validated;
+    }
+    catch (err) {
+        intermediateEmitter.fail(err);
+        throw err;
+    }
 }
 async function runLlmDeck(ctx) {
     const { deck, guardrails, depth, modelProvider, input, runId, inputProvided, initialUserMessage, } = ctx;
     const actionCallId = randomId("action");
     const start = performance.now();
-    const respondEnabled = Boolean(deck.respond);
     const useResponses = Boolean(ctx.responsesMode) ||
         ctx.state?.format === "responses";
+    const validateResponseItemEmission = createResponseItemEmissionValidator(deck);
+    const intermediateEmitter = ctx.parentActionCallId !== undefined
+        ? createIntermediateChildResponseEmitter({
+            runId,
+            actionCallId,
+            deckPath: deck.path,
+            parentActionCallId: ctx.parentActionCallId,
+            trace: ctx.trace,
+            validateItem: validateResponseItemEmission,
+            ensureActive: () => ensureRunActive(ctx.runDeadlineMs, ctx.signal),
+            allowEmission: ctx.intermediateOutputAllow,
+            errorContext: ctx.intermediateOutputErrorContext,
+            onEmit: ctx.onIntermediateOutputItem,
+        })
+        : undefined;
     const systemPrompt = buildSystemPrompt(deck);
     const refToolCallId = randomId("call");
     const messages = ctx.state?.messages?.length
@@ -2333,6 +3449,9 @@ async function runLlmDeck(ctx) {
         onStreamText: ctx.onStreamText,
         pushMessages: (msgs) => messages.push(...msgs.map(sanitizeMessage)),
         responsesMode: ctx.responsesMode,
+        intermediateOutputAllow: ctx.intermediateOutputAllow,
+        onIntermediateOutputItem: ctx.onIntermediateOutputItem,
+        intermediateOutputErrorContext: ctx.intermediateOutputErrorContext,
         permissions: ctx.permissions,
         workspacePermissions: ctx.workspacePermissions,
         workspacePermissionsBaseDir: ctx.workspacePermissionsBaseDir,
@@ -2343,6 +3462,10 @@ async function runLlmDeck(ctx) {
         signal: ctx.signal,
         onTool: ctx.onTool,
     });
+    const asyncActionJobs = createAsyncActionJobController({
+        state: ctx.state,
+        hasConfiguredAsyncActions: deck.actionDecks.some((action) => action.asyncStart?.mode === "allow"),
+    });
     let streamingBuffer = "";
     let streamingCommitted = false;
     const wrappedOnStreamText = (chunk) => {
@@ -2408,7 +3531,14 @@ async function runLlmDeck(ctx) {
         });
     }
     idleController.touch();
-    const tools = await buildToolDefs(deck, ctx.permissions);
+    const tools = await buildToolDefs(deck, ctx.permissions, {
+        parentActionCallId: ctx.parentActionCallId,
+        intermediateOutputAllow: ctx.intermediateOutputAllow,
+        asyncActionJobs,
+    });
+    const responseTextConfig = useResponses
+        ? toResponseTextConfig(deck)
+        : undefined;
     ctx.trace?.({
         type: "deck.start",
         runId,
@@ -2462,6 +3592,7 @@ async function runLlmDeck(ctx) {
             const projectedToolCalls = new Set();
             const projectedToolResults = new Set();
             const projectedToolNames = new Map();
+            const canonicalizeStreamEvent = createCanonicalStreamEventController();
             const result = (useResponses && responses)
                 ? await (async () => {
                     const responseItems = responseItemsFromMessages(messages);
@@ -2471,6 +3602,7 @@ async function runLlmDeck(ctx) {
                             model,
                             input: responseItems,
                             tools: tools,
+                            text: responseTextConfig,
                             stream: ctx.stream,
                             params: providerParams,
                         },
@@ -2479,8 +3611,11 @@ async function runLlmDeck(ctx) {
                         signal: ctx.signal,
                         onStreamEvent: (ctx.trace || ctx.onStreamText || deck.handlers?.onIdle)
                             ? (event) => {
+                                const normalizedEvent = validateResponseEventItems(event, validateResponseItemEmission);
+                                const streamEvent = canonicalizeStreamEvent(normalizedEvent);
+                                if (!streamEvent)
+                                    return;
                                 if (ctx.trace) {
-                                    const streamEvent = event;
                                     const handledAsResponse = traceOpenResponsesStreamEvent({
                                         streamEvent,
                                         runId,
@@ -2511,17 +3646,28 @@ async function runLlmDeck(ctx) {
                                         toolNames: projectedToolNames,
                                     });
                                 }
-                                if (event.type === "response.output_text.delta") {
+                                const eventType = typeof streamEvent.type === "string"
+                                    ? streamEvent.type
+                                    : "";
+                                if (eventType === "response.output_text.delta") {
                                     sawDelta = true;
-                                    wrappedOnStreamText(event.delta);
+                                    const delta = typeof streamEvent.delta === "string"
+                                        ? streamEvent.delta
+                                        : "";
+                                    if (delta)
+                                        wrappedOnStreamText(delta);
                                 }
-                                else if (event.type === "response.output_text.done" && !sawDelta) {
-                                    wrappedOnStreamText(event.text);
+                                else if (eventType === "response.output_text.done" && !sawDelta) {
+                                    const text = typeof streamEvent.text === "string"
+                                        ? streamEvent.text
+                                        : "";
+                                    if (text)
+                                        wrappedOnStreamText(text);
                                 }
                             }
                             : undefined,
                     });
-                    responseOutputItems = response.output ?? [];
+                    responseOutputItems = validateResponseOutputItems(response.output ?? [], validateResponseItemEmission, "response.output");
                     const mapped = mapResponseOutput(responseOutputItems);
                     return {
                         message: mapped.message,
@@ -2545,8 +3691,11 @@ async function runLlmDeck(ctx) {
                         : undefined,
                     onStreamEvent: ctx.trace
                         ? (event) => {
+                            const streamEvent = canonicalizeStreamEvent(event);
+                            if (!streamEvent)
+                                return;
                             const handledAsResponse = traceOpenResponsesStreamEvent({
-                                streamEvent: event,
+                                streamEvent,
                                 runId,
                                 actionCallId,
                                 deckPath: deck.path,
@@ -2561,12 +3710,12 @@ async function runLlmDeck(ctx) {
                                     actionCallId,
                                     deckPath: deck.path,
                                     model,
-                                    event,
+                                    event: streamEvent,
                                     parentActionCallId: ctx.parentActionCallId,
                                 });
                             }
                             projectStreamToolTraceEvents({
-                                streamEvent: event,
+                                streamEvent,
                                 runId,
                                 parentActionCallId: actionCallId,
                                 trace: ctx.trace,
@@ -2600,14 +3749,36 @@ async function runLlmDeck(ctx) {
                 const mergedMessages = base.messages && base.messages.length > 0
                     ? base.messages.map(sanitizeMessage)
                     : messages.map(sanitizeMessage);
-                const responseItems = useResponses
-                    ? responseItemsFromMessages(mergedMessages)
-                    : updated?.items ?? ctx.state?.items;
+                let responseItems;
+                if (useResponses) {
+                    const conversationalItems = responseItemsFromMessages(mergedMessages);
+                    const priorSupplemental = (updated?.items ?? ctx.state?.items ?? [])
+                        .filter((item) => isSupplementalResponseItem(item));
+                    const latestSupplemental = (responseOutputItems ?? [])
+                        .filter((item) => isSupplementalResponseItem(item));
+                    const supplementalItems = mergeSupplementalResponseItems(priorSupplemental, latestSupplemental);
+                    responseItems = [
+                        ...conversationalItems,
+                        ...supplementalItems,
+                    ];
+                }
+                else {
+                    responseItems = updated?.items ?? ctx.state?.items;
+                }
                 const priorRefs = updated?.messageRefs ?? ctx.state?.messageRefs ?? [];
                 const messageRefs = mergedMessages.map((m, idx) => priorRefs[idx] ?? { id: randomId("msg"), role: m.role });
                 const feedback = updated?.feedback ?? ctx.state?.feedback;
                 const traces = updated?.traces ?? ctx.state?.traces;
-                const meta = updated?.meta ?? ctx.state?.meta;
+                const sourceMeta = updated?.meta ?? ctx.state?.meta;
+                const nextMeta = sourceMeta ? { ...sourceMeta } : {};
+                const asyncActionSnapshot = asyncActionJobs.snapshot();
+                if (asyncActionSnapshot) {
+                    nextMeta[ASYNC_ACTION_JOBS_META_KEY] = asyncActionSnapshot;
+                }
+                else {
+                    delete nextMeta[ASYNC_ACTION_JOBS_META_KEY];
+                }
+                const meta = Object.keys(nextMeta).length > 0 ? nextMeta : undefined;
                 const notes = updated?.notes ?? ctx.state?.notes;
                 const conversationScore = updated?.conversationScore ??
                     ctx.state?.conversationScore;
@@ -2628,9 +3799,6 @@ async function runLlmDeck(ctx) {
                 };
             };
             if (result.toolCalls && result.toolCalls.length > 0) {
-                let responded = false;
-                let respondValue;
-                let endSignal;
                 const appendedMessages = [];
                 const toolCallText = streamingBuffer ||
                     (typeof message.content === "string" ? message.content : "");
@@ -2639,141 +3807,11 @@ async function runLlmDeck(ctx) {
                     streamingCommitted = true;
                 }
                 for (const call of result.toolCalls) {
-                    if (respondEnabled && call.name === GAMBIT_TOOL_RESPOND) {
-                        const status = typeof call.args?.status === "number"
-                            ? call.args.status
-                            : undefined;
-                        const message = typeof call.args?.message === "string"
-                            ? call.args.message
-                            : undefined;
-                        const code = typeof call.args?.code === "string"
-                            ? call.args.code
-                            : undefined;
-                        const meta = (call.args?.meta &&
-                            typeof call.args.meta === "object" &&
-                            call.args.meta !== null)
-                            ? call.args.meta
-                            : undefined;
-                        const rawPayload = call.args?.payload ?? call.args;
-                        const validatedPayload = validateOutput(deck, rawPayload, depth === 0);
-                        const respondEnvelope = {
-                            payload: validatedPayload,
-                        };
-                        if (status !== undefined)
-                            respondEnvelope.status = status;
-                        if (message !== undefined)
-                            respondEnvelope.message = message;
-                        if (code !== undefined)
-                            respondEnvelope.code = code;
-                        if (meta !== undefined)
-                            respondEnvelope.meta = meta;
-                        ctx.trace?.({
-                            type: "tool.call",
-                            runId,
-                            actionCallId: call.id,
-                            name: call.name,
-                            args: call.args,
-                            toolKind: "internal",
-                            parentActionCallId: actionCallId,
-                        });
-                        const toolContent = JSON.stringify(call.args ?? {});
-                        appendedMessages.push({
-                            role: "assistant",
-                            content: null,
-                            tool_calls: [{
-                                    id: call.id,
-                                    type: "function",
-                                    function: {
-                                        name: call.name,
-                                        arguments: JSON.stringify(call.args ?? {}),
-                                    },
-                                }],
-                        });
-                        appendedMessages.push({
-                            role: "tool",
-                            tool_call_id: call.id,
-                            name: call.name,
-                            content: toolContent,
-                        });
-                        respondValue = respondEnvelope;
-                        responded = true;
-                        ctx.trace?.({
-                            type: "tool.result",
-                            runId,
-                            actionCallId: call.id,
-                            name: call.name,
-                            result: respondEnvelope,
-                            toolKind: "internal",
-                            parentActionCallId: actionCallId,
-                        });
-                        continue;
+                    if (REMOVED_LEGACY_RESPONSE_TOOL_NAMES.has(call.name)) {
+                        throw legacyResponseToolMigrationError(`Model emitted removed synthetic tool "${call.name}" for deck ${deck.path}.`);
                     }
-                    if (deck.allowEnd && call.name === GAMBIT_TOOL_END) {
-                        const status = typeof call.args?.status === "number"
-                            ? call.args.status
-                            : undefined;
-                        const messageText = typeof call.args?.message === "string"
-                            ? call.args.message
-                            : undefined;
-                        const code = typeof call.args?.code === "string"
-                            ? call.args.code
-                            : undefined;
-                        const meta = (call.args?.meta &&
-                            typeof call.args.meta === "object" &&
-                            call.args.meta !== null)
-                            ? call.args.meta
-                            : undefined;
-                        const payload = call.args?.payload;
-                        ctx.trace?.({
-                            type: "tool.call",
-                            runId,
-                            actionCallId: call.id,
-                            name: call.name,
-                            args: call.args,
-                            toolKind: "internal",
-                            parentActionCallId: actionCallId,
-                        });
-                        const toolContent = JSON.stringify(call.args ?? {});
-                        appendedMessages.push({
-                            role: "assistant",
-                            content: null,
-                            tool_calls: [{
-                                    id: call.id,
-                                    type: "function",
-                                    function: {
-                                        name: call.name,
-                                        arguments: JSON.stringify(call.args ?? {}),
-                                    },
-                                }],
-                        });
-                        appendedMessages.push({
-                            role: "tool",
-                            tool_call_id: call.id,
-                            name: call.name,
-                            content: toolContent,
-                        });
-                        const signal = { __gambitEnd: true };
-                        if (status !== undefined)
-                            signal.status = status;
-                        if (messageText !== undefined)
-                            signal.message = messageText;
-                        if (code !== undefined)
-                            signal.code = code;
-                        if (meta !== undefined)
-                            signal.meta = meta;
-                        if (payload !== undefined)
-                            signal.payload = payload;
-                        endSignal = signal;
-                        ctx.trace?.({
-                            type: "tool.result",
-                            runId,
-                            actionCallId: call.id,
-                            name: call.name,
-                            result: signal,
-                            toolKind: "internal",
-                            parentActionCallId: actionCallId,
-                        });
-                        continue;
+                    if (isContextToolName(call.name)) {
+                        throw syntheticContextToolInvocationError(deck.path);
                     }
                     const actionRef = deck.actionDecks.find((a) => a.name === call.name);
                     const toolKind = actionRef ? "action" : "external";
@@ -2815,6 +3853,7 @@ async function runLlmDeck(ctx) {
                         defaultModel: ctx.defaultModel,
                         modelOverride: ctx.modelOverride,
                         trace: ctx.trace,
+                        stream: ctx.stream,
                         onStreamText: (ctx.onStreamText || deck.handlers?.onIdle)
                             ? wrappedOnStreamText
                             : undefined,
@@ -2830,7 +3869,14 @@ async function runLlmDeck(ctx) {
                         runDeadlineMs: ctx.runDeadlineMs,
                         workerSandbox: ctx.workerSandbox,
                         signal: ctx.signal,
+                        intermediateOutputAllow: ctx.intermediateOutputAllow,
+                        onIntermediateOutputItem: ctx.onIntermediateOutputItem,
+                        intermediateOutputErrorContext: ctx.intermediateOutputErrorContext,
                         onTool: ctx.onTool,
+                        emitIntermediateOutputItem: intermediateEmitter
+                            ? (item, source) => intermediateEmitter.emitOutputItem(item, source)
+                            : undefined,
+                        asyncActionJobs,
                     });
                     ctx.trace?.({
                         type: "tool.result",
@@ -2880,30 +3926,9 @@ async function runLlmDeck(ctx) {
                     const state = computeState(result.updatedState);
                     ctx.onStateUpdate(state);
                 }
-                if (endSignal) {
-                    ctx.trace?.({
-                        type: "deck.end",
-                        runId,
-                        deckPath: deck.path,
-                        actionCallId,
-                        parentActionCallId: ctx.parentActionCallId,
-                    });
-                    return endSignal;
-                }
-                if (responded) {
-                    ctx.trace?.({
-                        type: "deck.end",
-                        runId,
-                        deckPath: deck.path,
-                        actionCallId,
-                        parentActionCallId: ctx.parentActionCallId,
-                    });
-                    return respondValue;
-                }
                 continue;
             }
-            if (!respondEnabled &&
-                result.finishReason === "stop" &&
+            if (result.finishReason === "stop" &&
                 (message.content === null || message.content === undefined) &&
                 (!result.toolCalls || result.toolCalls.length === 0)) {
                 message = { ...message, content: "" };
@@ -2934,30 +3959,34 @@ async function runLlmDeck(ctx) {
                             .content,
                     });
                 }
-                if (!respondEnabled) {
-                    const validated = validateOutput(deck, message.content, depth === 0);
-                    ctx.trace?.({
-                        type: "deck.end",
-                        runId,
-                        deckPath: deck.path,
-                        actionCallId,
-                        parentActionCallId: ctx.parentActionCallId,
-                    });
-                    return validated;
-                }
-            }
-            if (respondEnabled && result.finishReason === "stop") {
-                continue;
+                const validated = validateOutput(deck, message.content, depth === 0);
+                intermediateEmitter?.complete();
+                ctx.trace?.({
+                    type: "deck.end",
+                    runId,
+                    deckPath: deck.path,
+                    actionCallId,
+                    parentActionCallId: ctx.parentActionCallId,
+                });
+                return validated;
             }
             if (passes >= guardrails.maxPasses) {
                 throw new Error("Max passes exceeded without completing");
             }
         }
+        throw new Error("Model did not complete within guardrails");
+    }
+    catch (err) {
+        intermediateEmitter?.fail(err);
+        throw err;
     }
     finally {
+        asyncActionJobs.cancelLiveJobs({
+            code: "async_job_parent_ended",
+            message: "Parent run ended before async action job reached terminal state.",
+        });
         idleController.stop();
     }
-    throw new Error("Model did not complete within guardrails");
 }
 async function handleToolCall(call, ctx) {
     ensureRunActive(ctx.runDeadlineMs, ctx.signal);
@@ -2965,6 +3994,7 @@ async function handleToolCall(call, ctx) {
         deckPath: ctx.parentDeck.path,
         actionName: call.name,
     };
+    let intermediateOutputView;
     const baseComplete = (payload) => JSON.stringify({
         runId: ctx.runId,
         actionCallId: call.id,
@@ -2975,6 +4005,9 @@ async function handleToolCall(call, ctx) {
         message: payload.message,
         code: payload.code,
         meta: payload.meta,
+        ...(intermediateOutputView
+            ? { intermediateOutput: intermediateOutputView }
+            : {}),
     });
     const extraMessages = [];
     const started = performance.now();
@@ -2988,6 +4021,98 @@ async function handleToolCall(call, ctx) {
                 message,
             }),
         });
+        if (call.name === BUILTIN_TOOL_EMIT_OUTPUT_ITEM) {
+            if (!ctx.emitIntermediateOutputItem) {
+                return {
+                    toolContent: baseComplete({
+                        status: 400,
+                        code: "invalid_tool_context",
+                        message: `${BUILTIN_TOOL_EMIT_OUTPUT_ITEM} is only available inside child LLM action decks`,
+                    }),
+                };
+            }
+            let item;
+            try {
+                item = parseEmitOutputItemArgs(call.args);
+            }
+            catch (err) {
+                return {
+                    toolContent: baseComplete({
+                        status: 400,
+                        code: "invalid_input",
+                        message: err instanceof Error ? err.message : String(err),
+                    }),
+                };
+            }
+            try {
+                ctx.emitIntermediateOutputItem(item, `tool.${BUILTIN_TOOL_EMIT_OUTPUT_ITEM}`);
+            }
+            catch (err) {
+                const errorCode = typeof err?.code === "string"
+                    ? err.code
+                    : "invalid_input";
+                return {
+                    toolContent: baseComplete({
+                        status: errorCode === INTERMEDIATE_OUTPUT_DISALLOWED_CODE
+                            ? 403
+                            : 400,
+                        code: errorCode,
+                        message: err instanceof Error ? err.message : String(err),
+                    }),
+                };
+            }
+            return {
+                toolContent: baseComplete({
+                    status: 200,
+                    payload: { emitted: true, type: item.type },
+                }),
+            };
+        }
+        if (call.name === BUILTIN_TOOL_CONSUME_ASYNC_ACTION) {
+            if (!ctx.asyncActionJobs) {
+                return {
+                    toolContent: baseComplete({
+                        status: 400,
+                        code: "invalid_tool_context",
+                        message: `${BUILTIN_TOOL_CONSUME_ASYNC_ACTION} is unavailable for this deck`,
+                    }),
+                };
+            }
+            let parsedArgs;
+            try {
+                parsedArgs = parseConsumeAsyncActionArgs(call.args);
+            }
+            catch (err) {
+                return {
+                    toolContent: baseComplete({
+                        status: 400,
+                        code: "invalid_input",
+                        message: err instanceof Error ? err.message : String(err),
+                    }),
+                };
+            }
+            const consumed = await ctx.asyncActionJobs.consume({
+                ...parsedArgs,
+                runDeadlineMs: ctx.runDeadlineMs,
+                signal: ctx.signal,
+            });
+            if (!consumed.ok) {
+                return {
+                    toolContent: baseComplete({
+                        status: consumed.status,
+                        code: consumed.code,
+                        message: consumed.message,
+                        payload: consumed.payload,
+                    }),
+                };
+            }
+            return {
+                toolContent: baseComplete({
+                    status: 200,
+                    payload: consumed.payload,
+                }),
+            };
+        }
         if (call.name === BUILTIN_TOOL_READ_FILE) {
             let targetPath;
             try {
@@ -3452,6 +4577,139 @@ async function handleToolCall(call, ctx) {
             };
         }
     }
+    const inheritedIntermediateOutputAllow = ctx.intermediateOutputAllow ?? true;
+    const actionDeclaresIntermediateOutput = action.intermediateOutput?.emit === "allow";
+    const actionIntermediateOutputAllow = inheritedIntermediateOutputAllow &&
+        actionDeclaresIntermediateOutput;
+    const actionIntermediateOutputItems = [];
+    const actionIntermediateOutputErrorContext = inheritedIntermediateOutputAllow
+        ? {
+            actionName: action.name,
+            parentDeckPath: ctx.parentDeck.path,
+        }
+        : (ctx.intermediateOutputErrorContext ?? {
+            actionName: action.name,
+            parentDeckPath: ctx.parentDeck.path,
+        });
+    const actionIntermediateOutputCapture = actionIntermediateOutputAllow
+        ? (emission) => {
+            actionIntermediateOutputItems.push(emission);
+            ctx.onIntermediateOutputItem?.(emission);
+        }
+        : undefined;
+    const actionAsyncStartAllowed = action.asyncStart?.mode === "allow";
+    if (actionAsyncStartAllowed) {
+        if (!ctx.asyncActionJobs) {
+            return {
+                toolContent: baseComplete({
+                    status: 500,
+                    code: "async_job_unavailable",
+                    message: "Async action start is configured but async job controller is unavailable",
+                }),
+            };
+        }
+        const job = ctx.asyncActionJobs.startJob({
+            actionName: action.name,
+            actionPath: action.path,
+        });
+        const controller = new AbortController();
+        const childSignal = mergeAbortSignals(ctx.signal, controller.signal);
+        const asyncIntermediateOutputCapture = actionIntermediateOutputAllow
+            ? (emission) => {
+                job.appendIntermediateOutput(emission);
+                ctx.onIntermediateOutputItem?.(emission);
+            }
+            : undefined;
+        const runPromise = (async () => {
+            try {
+                const result = await runDeck({
+                    path: action.path,
+                    input: actionInput,
+                    modelProvider: ctx.modelProvider,
+                    isRoot: false,
+                    guardrails: ctx.guardrails,
+                    depth: ctx.depth + 1,
+                    parentActionCallId: call.id,
+                    runId: ctx.runId,
+                    defaultModel: ctx.defaultModel,
+                    modelOverride: ctx.modelOverride,
+                    trace: ctx.trace,
+                    stream: ctx.stream,
+                    onStreamText: ctx.onStreamText,
+                    responsesMode: ctx.responsesMode,
+                    initialUserMessage: undefined,
+                    intermediateOutputAllow: actionIntermediateOutputAllow,
+                    onIntermediateOutputItem: asyncIntermediateOutputCapture,
+                    intermediateOutputErrorContext: actionIntermediateOutputErrorContext,
+                    parentPermissions: ctx.permissions,
+                    referencePermissions: action.permissions,
+                    referencePermissionsBaseDir: path.dirname(ctx.parentDeck.path),
+                    workspacePermissions: ctx.workspacePermissions,
+                    workspacePermissionsBaseDir: ctx.workspacePermissionsBaseDir,
+                    sessionPermissions: ctx.sessionPermissions,
+                    sessionPermissionsBaseDir: ctx.sessionPermissionsBaseDir,
+                    runDeadlineMs: ctx.runDeadlineMs,
+                    workerSandbox: ctx.workerSandbox,
+                    signal: childSignal,
+                    onTool: ctx.onTool,
+                });
+                const normalized = normalizeChildResult(result);
+                if (action.responseSchema) {
+                    normalized.payload = validateWithSchema(action.responseSchema, normalized.payload);
+                }
+                job.complete(normalized);
+            }
+            catch (err) {
+                const handled = await maybeHandleError({
+                    err,
+                    call,
+                    ctx,
+                    action,
+                });
+                if (handled) {
+                    const handledEnvelope = parseToolContentEnvelope(handled.toolContent);
+                    job.fail({
+                        state: "failed",
+                        status: handledEnvelope?.status,
+                        payload: handledEnvelope?.payload,
+                        message: handledEnvelope?.message ??
+                            (err instanceof Error ? err.message : String(err)),
+                        code: handledEnvelope?.code,
+                        meta: handledEnvelope?.meta,
+                    });
+                    return;
+                }
+                if (isRunCanceledError(err)) {
+                    job.fail({
+                        state: "canceled",
+                        status: 499,
+                        code: typeof err?.code === "string"
+                            ? err.code
+                            : "run_canceled",
+                        message: err instanceof Error ? err.message : String(err),
+                    });
+                    return;
+                }
+                job.fail({
+                    state: "failed",
+                    code: typeof err?.code === "string"
+                        ? err.code
+                        : undefined,
+                    message: err instanceof Error ? err.message : String(err),
+                });
+            }
+        })();
+        job.bindLiveRun(runPromise, controller);
+        return {
+            toolContent: baseComplete({
+                status: 202,
+                code: "async_action_started",
+                payload: {
+                    job: job.handle,
+                },
+            }),
+        };
+    }
     const busyCfg = ctx.parentDeck.handlers?.onBusy ??
         ctx.parentDeck.handlers?.onInterval;
     const busyDelay = busyCfg?.delayMs ?? DEFAULT_STATUS_DELAY_MS;
@@ -3479,6 +4737,9 @@ async function handleToolCall(call, ctx) {
                 onStreamText: ctx.onStreamText,
                 responsesMode: ctx.responsesMode,
                 initialUserMessage: undefined,
+                intermediateOutputAllow: actionIntermediateOutputAllow,
+                onIntermediateOutputItem: actionIntermediateOutputCapture,
+                intermediateOutputErrorContext: actionIntermediateOutputErrorContext,
                 parentPermissions: ctx.permissions,
                 referencePermissions: action.permissions,
                 referencePermissionsBaseDir: path.dirname(ctx.parentDeck.path),
@@ -3523,6 +4784,9 @@ async function handleToolCall(call, ctx) {
                 onStreamText: ctx.onStreamText,
                 responsesMode: ctx.responsesMode,
                 initialUserMessage: undefined,
+                intermediateOutputAllow: actionIntermediateOutputAllow,
+                onIntermediateOutputItem: actionIntermediateOutputCapture,
+                intermediateOutputErrorContext: actionIntermediateOutputErrorContext,
                 permissions: ctx.permissions,
                 workspacePermissions: ctx.workspacePermissions,
                 workspacePermissionsBaseDir: ctx.workspacePermissionsBaseDir,
@@ -3592,6 +4856,12 @@ async function handleToolCall(call, ctx) {
     if (action.responseSchema) {
         normalized.payload = validateWithSchema(action.responseSchema, normalized.payload);
     }
+    if (actionIntermediateOutputAllow) {
+        intermediateOutputView = {
+            policy: "allow",
+            items: actionIntermediateOutputItems,
+        };
+    }
     const toolContent = baseComplete(normalized);
     if (busyCfg?.path) {
         const elapsedFromAction = performance.now() - started;
@@ -3615,6 +4885,9 @@ async function handleToolCall(call, ctx) {
                     onStreamText: ctx.onStreamText,
                     responsesMode: ctx.responsesMode,
                     initialUserMessage: undefined,
+                    intermediateOutputAllow: actionIntermediateOutputAllow,
+                    onIntermediateOutputItem: actionIntermediateOutputCapture,
+                    intermediateOutputErrorContext: actionIntermediateOutputErrorContext,
                     permissions: ctx.permissions,
                     workspacePermissions: ctx.workspacePermissions,
                     workspacePermissionsBaseDir: ctx.workspacePermissionsBaseDir,
@@ -3635,24 +4908,6 @@ async function handleToolCall(call, ctx) {
             }
         }
     }
-    const completeEventId = randomId("event");
-    extraMessages.push({
-        role: "assistant",
-        content: null,
-        tool_calls: [{
-                id: completeEventId,
-                type: "function",
-                function: {
-                    name: GAMBIT_TOOL_COMPLETE,
-                    arguments: toolContent,
-                },
-            }],
-    }, {
-        role: "tool",
-        tool_call_id: completeEventId,
-        name: GAMBIT_TOOL_COMPLETE,
-        content: toolContent,
-    });
     stopBusy();
     ctx.idle?.touch();
     return { toolContent, extraMessages };
@@ -3671,6 +4926,27 @@ function normalizeChildResult(result) {
     }
     return { payload: result };
 }
+function parseToolContentEnvelope(content) {
+    try {
+        const parsed = JSON.parse(content);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            return undefined;
+        }
+        const rec = parsed;
+        return {
+            status: typeof rec.status === "number" ? rec.status : undefined,
+            payload: rec.payload,
+            message: typeof rec.message === "string" ? rec.message : undefined,
+            code: typeof rec.code === "string" ? rec.code : undefined,
+            meta: rec.meta && typeof rec.meta === "object" && !Array.isArray(rec.meta)
+                ? rec.meta
+                : undefined,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
 async function runBusyHandler(args) {
     try {
         ensureRunActive(args.runDeadlineMs, args.signal);
@@ -3701,6 +4977,9 @@ async function runBusyHandler(args) {
             responsesMode: args.responsesMode,
             initialUserMessage: args.initialUserMessage,
             inputProvided: true,
+            intermediateOutputAllow: args.intermediateOutputAllow,
+            onIntermediateOutputItem: args.onIntermediateOutputItem,
+            intermediateOutputErrorContext: args.intermediateOutputErrorContext,
             parentPermissions: args.permissions,
             workspacePermissions: args.workspacePermissions,
             workspacePermissionsBaseDir: args.workspacePermissionsBaseDir,
@@ -3787,6 +5066,9 @@ function createIdleController(args) {
                     stream: args.stream,
                     onStreamText: args.onStreamText,
                     responsesMode: args.responsesMode,
+                    intermediateOutputAllow: args.intermediateOutputAllow,
+                    onIntermediateOutputItem: args.onIntermediateOutputItem,
+                    intermediateOutputErrorContext: args.intermediateOutputErrorContext,
                     permissions: args.permissions,
                     workspacePermissions: args.workspacePermissions,
                     workspacePermissionsBaseDir: args.workspacePermissionsBaseDir,
@@ -3862,6 +5144,9 @@ async function runIdleHandler(args) {
             responsesMode: args.responsesMode,
             initialUserMessage: undefined,
             inputProvided: true,
+            intermediateOutputAllow: args.intermediateOutputAllow,
+            onIntermediateOutputItem: args.onIntermediateOutputItem,
+            intermediateOutputErrorContext: args.intermediateOutputErrorContext,
             parentPermissions: args.permissions,
             workspacePermissions: args.workspacePermissions,
             workspacePermissionsBaseDir: args.workspacePermissionsBaseDir,
@@ -3938,6 +5223,9 @@ async function maybeHandleError(args) {
             responsesMode: args.ctx.responsesMode,
             initialUserMessage: undefined,
             inputProvided: true,
+            intermediateOutputAllow: args.ctx.intermediateOutputAllow,
+            onIntermediateOutputItem: args.ctx.onIntermediateOutputItem,
+            intermediateOutputErrorContext: args.ctx.intermediateOutputErrorContext,
             parentPermissions: args.ctx.permissions,
             workspacePermissions: args.ctx.workspacePermissions,
             workspacePermissionsBaseDir: args.ctx.workspacePermissionsBaseDir,
@@ -3974,28 +5262,7 @@ async function maybeHandleError(args) {
             code,
             meta,
         });
-        const callId = randomId("event");
-        const extraMessages = [
-            {
-                role: "assistant",
-                content: null,
-                tool_calls: [{
-                        id: callId,
-                        type: "function",
-                        function: {
-                            name: GAMBIT_TOOL_COMPLETE,
-                            arguments: content,
-                        },
-                    }],
-            },
-            {
-                role: "tool",
-                tool_call_id: callId,
-                name: GAMBIT_TOOL_COMPLETE,
-                content,
-            },
-        ];
-        return { toolContent: content, extraMessages };
+        return { toolContent: content };
     }
     catch {
         // Fallback when the handler itself fails: still return a structured error envelope
@@ -4017,28 +5284,7 @@ async function maybeHandleError(args) {
             code,
             meta: { handlerFailed: true },
         });
-        const callId = randomId("event");
-        const extraMessages = [
-            {
-                role: "assistant",
-                content: null,
-                tool_calls: [{
-                        id: callId,
-                        type: "function",
-                        function: {
-                            name: GAMBIT_TOOL_COMPLETE,
-                            arguments: content,
-                        },
-                    }],
-            },
-            {
-                role: "tool",
-                tool_call_id: callId,
-                name: GAMBIT_TOOL_COMPLETE,
-                content,
-            },
-        ];
-        return { toolContent: content, extraMessages };
+        return { toolContent: content };
     }
 }
 function buildSystemPrompt(deck) {
@@ -4090,6 +5336,53 @@ function parseToolLimit(value, fallback, max) {
         return fallback;
     return Math.min(max, Math.max(1, Number(value)));
 }
+function parseAsyncActionWaitMs(value) {
+    if (value === undefined || value === null)
+        return 0;
+    if (!Number.isInteger(value)) {
+        throw new Error("wait_ms must be a non-negative integer");
+    }
+    return Math.min(ASYNC_ACTION_JOB_MAX_WAIT_MS, Math.max(0, Number(value)));
+}
+function parseConsumeAsyncActionArgs(args) {
+    const rawJobId = typeof args.job_id === "string"
+        ? args.job_id
+        : typeof args.jobId === "string"
+            ? args.jobId
+            : "";
+    const jobId = rawJobId.trim();
+    if (!jobId) {
+        throw new Error("job_id is required");
+    }
+    const cursor = args.cursor === undefined ? 0 : args.cursor;
+    if (!Number.isInteger(cursor) || Number(cursor) < 0) {
+        throw new Error("cursor must be a non-negative integer");
+    }
+    const limit = parseToolLimit(args.limit, 32, 256);
+    const waitMs = parseAsyncActionWaitMs(Object.hasOwn(args, "wait_ms") ? args.wait_ms : args.waitMs);
+    return {
+        jobId,
+        cursor: Number(cursor),
+        limit,
+        waitMs,
+    };
+}
+function parseEmitOutputItemArgs(args) {
+    const rawItem = Object.hasOwn(args, "item") ? args.item : args;
+    if (!rawItem || typeof rawItem !== "object" || Array.isArray(rawItem)) {
+        throw new Error("item must be an object matching the OpenResponses response item shape");
+    }
+    const canonicalItem = canonicalizeJsonValue(rawItem);
+    if (!canonicalItem || typeof canonicalItem !== "object" ||
+        Array.isArray(canonicalItem)) {
+        throw new Error("item must be an object matching the OpenResponses response item shape");
+    }
+    const type = canonicalItem.type;
+    if (typeof type !== "string" || !type.trim()) {
+        throw new Error("item.type must be a non-empty string");
+    }
+    return canonicalItem;
+}
 function toStringArray(value) {
     if (!Array.isArray(value))
         return [];
@@ -4127,7 +5420,7 @@ function applySimplePatch(content, edits) {
     }
     return { next, applied };
 }
-async function buildToolDefs(deck, permissions) {
+async function buildToolDefs(deck, permissions, options) {
     const defs = [];
     const addBuiltinTools = () => {
         if (hasAnyScope(permissions.read)) {
@@ -4235,48 +5528,51 @@ async function buildToolDefs(deck, permissions) {
                 },
             });
         }
-    };
-    addBuiltinTools();
-    if (deck.allowEnd) {
-        defs.push({
-            type: "function",
-            function: {
-                name: GAMBIT_TOOL_END,
-                description: "End the current run once all goals are complete.",
-                parameters: {
-                    type: "object",
-                    properties: {
-                        status: { type: "number" },
-                        payload: {},
-                        message: { type: "string" },
-                        code: { type: "string" },
-                        meta: { type: "object" },
+        if (options?.parentActionCallId !== undefined &&
+            (options.intermediateOutputAllow ?? true)) {
+            defs.push({
+                type: "function",
+                function: {
+                    name: BUILTIN_TOOL_EMIT_OUTPUT_ITEM,
+                    description: "Emit a supplemental output item to the parent before action completion.",
+                    parameters: {
+                        type: "object",
+                        properties: {
+                            item: {
+                                type: "object",
+                                additionalProperties: true,
+                            },
+                        },
+                        required: ["item"],
+                        additionalProperties: false,
                     },
-                    additionalProperties: true,
                 },
-            },
-        });
-    }
-    if (deck.respond) {
-        defs.push({
-            type: "function",
-            function: {
-                name: GAMBIT_TOOL_RESPOND,
-                description: "Finish the current deck with a structured response.",
-                parameters: {
-                    type: "object",
-                    properties: {
-                        status: { type: "number" },
-                        payload: {},
-                        message: { type: "string" },
-                        code: { type: "string" },
-                        meta: { type: "object" },
+            });
+        }
+        if (options?.asyncActionJobs &&
+            (options.asyncActionJobs.hasConfiguredAsyncActions ||
+                options.asyncActionJobs.hasLiveJobs())) {
+            defs.push({
+                type: "function",
+                function: {
+                    name: BUILTIN_TOOL_CONSUME_ASYNC_ACTION,
+                    description: "Consume ordered async action job events/results by cursor.",
+                    parameters: {
+                        type: "object",
+                        properties: {
+                            job_id: { type: "string" },
+                            cursor: { type: "number" },
+                            limit: { type: "number" },
+                            wait_ms: { type: "number" },
+                        },
+                        required: ["job_id"],
+                        additionalProperties: false,
                     },
-                    additionalProperties: true,
                 },
-            },
-        });
-    }
+            });
+        }
+    };
+    addBuiltinTools();
     for (const action of deck.actionDecks) {
         if (isBuiltinTool(action.name)) {
             throw new Error(`Action name ${action.name} conflicts with a built-in tool name`);