@kortyx/agent 0.18.0 → 0.20.0

package/dist/index.js

@@ -52,6 +52,7 @@ var require_dist = __commonJS({
     var index_exports2 = {};
     __export2(index_exports2, {
       WorkflowCallError: () => WorkflowCallError,
+      completeResponse: () => completeResponse,
       createWorkflowHooks: () => createWorkflowHooks,
       emitWorkflowCall: () => emitWorkflowCall2,
       runWithHookContext: () => runWithHookContext,
@@ -66,6 +67,7 @@ var require_dist = __commonJS({
       workflowCallFingerprint: () => workflowCallFingerprint
     });
     module2.exports = __toCommonJS2(index_exports2);
+    var import_zod6 = require("zod");
     var import_node_async_hooks = require("async_hooks");
     var storage = new import_node_async_hooks.AsyncLocalStorage();
     var isRecord5 = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
@@ -155,7 +157,7 @@ var require_dist = __commonJS({
       if (!usage) return void 0;
       const input = usage.input ?? 0;
       const output = usage.output ?? 0;
-      const total = usage.total ?? input + output + (usage.reasoning ?? 0);
+      const total = usage.total ?? input + output + (usage.outputIncludesReasoning ? 0 : usage.reasoning ?? 0);
       if (input === 0 && output === 0 && total === 0) {
         return void 0;
       }
@@ -218,7 +220,29 @@ var require_dist = __commonJS({
       }
       return ctx;
     }
-    var import_core5 = require("@kortyx/core");
+    function snapshotHookState() {
+      const ctx = getHookContext();
+      return {
+        ...ctx.state,
+        lastNode: ctx.node.graph.node,
+        runtime: { ...ctx.state.runtime, ...buildRuntimeStateUpdates(ctx) }
+      };
+    }
+    var optionsSchema = import_zod6.z.object({
+      message: import_zod6.z.string().optional(),
+      data: import_zod6.z.json().optional()
+    }).strict();
+    async function completeResponse(options = {}) {
+      const ctx = getHookContext();
+      const parsed = optionsSchema.parse(options);
+      if (!ctx.node.completeResponse) {
+        throw new Error(
+          "completeResponse requires an agent-managed root workflow."
+        );
+      }
+      await ctx.node.completeResponse(parsed, snapshotHookState());
+    }
+    var import_core6 = require("@kortyx/core");
     var resolveReasonCheckpointKey = (args) => typeof args.id === "string" && args.id.length > 0 ? `__useReason:${args.id}` : `__useReason:auto:${args.autoIndex}`;
     var readReasonCheckpoint = (raw) => {
       if (!raw || typeof raw !== "object") return void 0;
@@ -269,7 +293,7 @@ var require_dist = __commonJS({
     };
     var awaitInterruptInternal = (args) => {
       const ctx = getHookContext();
-      (0, import_core5.throwIfExecutionAborted)(ctx.node.abortSignal);
+      (0, import_core6.throwIfExecutionAborted)(ctx.node.abortSignal);
       const request = parseWithSchema(
         args.requestSchema,
         args.request,
@@ -409,7 +433,7 @@ var require_dist = __commonJS({
       });
     };
     async function runReasonEngine(args) {
-      const stream = args.stream ?? args.model.options?.streaming ?? true;
+      let stream = args.stream ?? args.model.options?.streaming ?? true;
       const emit = args.emit ?? true;
       const temperature = args.temperature ?? args.model.options?.temperature ?? args.defaultTemperature;
       const maxOutputTokens = args.maxOutputTokens ?? args.model.options?.maxOutputTokens;
@@ -417,7 +441,14 @@ var require_dist = __commonJS({
       const abortSignal = args.abortSignal ?? args.model.options?.abortSignal;
       const reasoning = args.reasoning ?? args.model.options?.reasoning;
       const responseFormat = args.responseFormat ?? args.model.options?.responseFormat;
-      const providerOptions = args.providerOptions ?? args.model.options?.providerOptions;
+      const defaults = args.model.options?.providerOptions;
+      const providerOptions = defaults || args.providerOptions ? { ...defaults, ...args.providerOptions } : void 0;
+      for (const [key, value] of Object.entries(args.providerOptions ?? {})) {
+        const previous = defaults?.[key];
+        if (previous && value && typeof previous === "object" && typeof value === "object" && !Array.isArray(previous) && !Array.isArray(value)) {
+          if (providerOptions) providerOptions[key] = { ...previous, ...value };
+        }
+      }
       const tools = args.tools ?? args.model.options?.tools;
       (0, import_core22.throwIfExecutionAborted)(abortSignal);
       const model = args.model.provider.getModel(args.model.modelId, {
@@ -431,6 +462,7 @@ var require_dist = __commonJS({
         ...tools !== void 0 ? { tools } : {},
         ...providerOptions !== void 0 ? { providerOptions } : {}
       });
+      if (tools?.length && !model.supportsToolStreaming) stream = false;
       const messages = args.messages !== void 0 ? args.messages : [
         ...typeof args.system === "string" && args.system.length > 0 ? [{ role: "system", content: args.system }] : [],
         { role: "user", content: String(args.input ?? "") }
@@ -458,7 +490,9 @@ var require_dist = __commonJS({
         },
         telemetry: {
           ...args.telemetry ?? {},
-          input: args.telemetry?.input ?? messages
+          input: args.telemetry?.input ?? messages.map(
+            ({ continuation: _continuation, raw: _raw, ...message }) => message
+          )
         }
       });
       const modelRequestStartedAt = Date.now();
@@ -489,7 +523,11 @@ var require_dist = __commonJS({
         });
       };
       const failTrace = (span, error) => {
+        const detail = error;
         span?.fail?.(error, {
+          ...detail?.usage ? { usage: detail.usage } : {},
+          ...detail?.finishReason ? { finishReason: detail.finishReason } : {},
+          ...detail?.providerMetadata ? { providerMetadata: detail.providerMetadata } : {},
           attributes: {
             providerId: args.model.provider.id,
             modelId: args.model.modelId
@@ -498,6 +536,7 @@ var require_dist = __commonJS({
       };
       try {
         if (stream) {
+          let continuation;
           let final = "";
           let raw;
           let usage;
@@ -536,6 +575,7 @@ var require_dist = __commonJS({
                 break;
               }
               case "finish": {
+                continuation = chunk.continuation;
                 if (chunk.raw !== void 0) {
                   raw = chunk.raw;
                 }
@@ -584,6 +624,7 @@ var require_dist = __commonJS({
           }
           const result2 = {
             text: final,
+            ...continuation ? { continuation } : {},
             ...raw !== void 0 ? { raw } : {},
             ...usage !== void 0 ? { usage } : {},
             ...finishReason !== void 0 ? { finishReason } : {},
@@ -597,6 +638,7 @@ var require_dist = __commonJS({
         }
         const response = await model.invoke(messages);
         (0, import_core22.throwIfExecutionAborted)(abortSignal);
+        if (response.content) args.onTextChunk?.(response.content);
         if (emit) {
           emitNodeEvent(args.emitEvent, args.nodeId, "text-start", {
             ...commonMeta
@@ -613,6 +655,7 @@ var require_dist = __commonJS({
         }
         const result = {
           text: response.content,
+          ...response.continuation ? { continuation: response.continuation } : {},
           ...response.raw !== void 0 ? { raw: response.raw } : {},
           ...response.usage !== void 0 ? { usage: response.usage } : {},
           ...response.finishReason !== void 0 ? { finishReason: response.finishReason } : {},
@@ -644,472 +687,184 @@ var require_dist = __commonJS({
       );
       (0, import_core32.throwIfExecutionAborted)(abortSignal);
       ctx.node.consumeExecution?.("maxModelPasses");
-      return runReasonEngine({
-        model: args.model,
-        input: inputOverride ?? args.input,
-        system: args.system,
-        temperature: args.temperature,
-        maxOutputTokens: args.maxOutputTokens,
-        stopSequences: args.stopSequences,
-        abortSignal,
-        reasoning: args.reasoning,
-        responseFormat: args.responseFormat,
-        providerOptions: args.providerOptions,
-        tools: args.tools,
-        messages: args.messages,
-        defaultTemperature: ctx.node.config?.model?.temperature,
-        stream: args.stream,
-        emit: args.emit,
-        onTextChunk: args.onTextChunk,
-        telemetry: args.telemetry,
-        nodeId: ctx.node.graph.node,
-        emitEvent: ctx.node.emit,
-        reasonTrace: ctx.reasonTrace,
-        id: meta.id,
-        opId: meta.opId
-      });
-    }
-    var tryJsonParse = (value) => {
       try {
-        return { ok: true, value: JSON.parse(value) };
+        return await runReasonEngine({
+          model: args.model,
+          input: inputOverride ?? args.input,
+          system: args.system,
+          temperature: args.temperature,
+          maxOutputTokens: args.maxOutputTokens,
+          stopSequences: args.stopSequences,
+          abortSignal,
+          reasoning: args.reasoning,
+          responseFormat: args.responseFormat,
+          providerOptions: args.providerOptions,
+          tools: args.tools,
+          messages: args.messages,
+          defaultTemperature: ctx.node.config?.model?.temperature,
+          stream: args.stream,
+          emit: args.emit,
+          onTextChunk: args.onTextChunk,
+          telemetry: args.telemetry,
+          nodeId: ctx.node.graph.node,
+          emitEvent: ctx.node.emit,
+          reasonTrace: ctx.reasonTrace,
+          id: meta.id,
+          opId: meta.opId
+        });
       } catch (error) {
-        return {
-          ok: false,
-          error: error instanceof Error ? error.message : String(error)
-        };
+        const usage = error?.usage;
+        if (usage) accumulateTokenUsage(usage);
+        throw error;
       }
-    };
-    var extractJsonCodeBlock = (value) => {
-      const match = value.match(/```(?:json)?\s*([\s\S]*?)```/i);
-      if (!match || typeof match[1] !== "string") return null;
-      const inner = match[1].trim();
-      return inner.length > 0 ? inner : null;
-    };
-    var tryStringify = (value) => {
-      if (typeof value === "string") return value;
+    }
+    var import_zod22 = require("zod");
+    function inferOutputFormat(schema, explicit) {
+      if (explicit) return { responseFormat: explicit };
+      if (!schema) return {};
       try {
-        return JSON.stringify(value, null, 2);
+        const json = (0, import_zod22.toJSONSchema)(schema);
+        const clean = (value) => {
+          if (Array.isArray(value)) return value.map(clean);
+          if (!value || typeof value !== "object") return value;
+          const object = value;
+          if ([
+            "allOf",
+            "not",
+            "dependentRequired",
+            "dependentSchemas",
+            "if",
+            "then",
+            "else",
+            "prefixItems"
+          ].some((key) => key in object))
+            throw new Error(
+              "Schema composition requires an explicit provider schema"
+            );
+          if (object.type === "object") {
+            if (object.additionalProperties !== false)
+              throw new Error(
+                "Dynamic properties require an explicit provider schema"
+              );
+            const properties = object.properties;
+            const required = object.required;
+            if (properties && Object.keys(properties).some((key) => !required?.includes(key))) {
+              throw new Error(
+                "Optional properties require an explicit provider schema"
+              );
+            }
+          }
+          return Object.fromEntries(
+            Object.entries(object).filter(([key]) => key !== "$schema" && key !== "default").map(([key, child]) => {
+              if ((key === "properties" || key === "$defs" || key === "definitions") && child && typeof child === "object")
+                return [
+                  key,
+                  Object.fromEntries(
+                    Object.entries(child).map(([name, definition]) => [
+                      name,
+                      clean(definition)
+                    ])
+                  )
+                ];
+              return [
+                key,
+                key === "enum" || key === "const" ? child : clean(child)
+              ];
+            })
+          );
+        };
+        if (json.type !== "object")
+          throw new Error("The provider schema must have an object root");
+        return { responseFormat: { type: "json", schema: clean(json) } };
       } catch {
-        return String(value);
+        return {
+          responseFormat: { type: "json" },
+          warnings: [
+            {
+              type: "compatibility",
+              feature: "outputSchema",
+              details: "This validator cannot be inferred as a strict provider JSON schema. Kortyx still validates the final output locally. Supply responseFormat.schema to enforce a wire schema."
+            }
+          ]
+        };
       }
-    };
-    var isRecord22 = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
-    var resolveOutputCandidate = (text) => {
-      const trimmed = text.trim();
-      if (!trimmed) return text;
-      const direct = tryJsonParse(trimmed);
-      if (direct.ok) return direct.value;
-      const block = extractJsonCodeBlock(trimmed);
-      if (block) {
-        const parsedBlock = tryJsonParse(block);
-        if (parsedBlock.ok) return parsedBlock.value;
+    }
+    var resolveAppendFieldPaths = (cfg) => {
+      const fields = cfg?.fields;
+      if (!fields) return [];
+      const appendPaths = Object.entries(fields).filter(([, mode]) => mode === "append").map(([path]) => path);
+      for (const path of appendPaths) {
+        assertStructuredPath(path, "useReason structured append");
       }
-      return text;
-    };
-    var looksLikeStructuredJsonAttempt = (value) => {
-      const trimmed = value.trim();
-      if (!trimmed) return false;
-      return trimmed.startsWith("{") || trimmed.startsWith("[") || /^```(?:json)?/i.test(trimmed);
+      return appendPaths;
     };
-    var isLikelyTruncatedStructuredOutput = (text) => {
-      const trimmed = text.trim();
-      if (!looksLikeStructuredJsonAttempt(trimmed)) return false;
-      const direct = tryJsonParse(trimmed);
-      if (!direct.ok && direct.error) return true;
-      const block = extractJsonCodeBlock(trimmed);
-      if (!block) return false;
-      const parsedBlock = tryJsonParse(block);
-      return !parsedBlock.ok && Boolean(parsedBlock.error);
+    var resolveSetFieldPaths = (cfg) => {
+      const fields = cfg?.fields;
+      if (!fields) return [];
+      const setPaths = Object.entries(fields).filter(([, mode]) => mode === "set").map(([path]) => path);
+      for (const path of setPaths) {
+        assertStructuredPath(path, "useReason structured set");
+      }
+      return setPaths;
     };
-    var createTruncatedStructuredOutputError = (label) => new Error(
-      `${label} was truncated before producing valid structured output. The model stopped due to output length. Increase maxOutputTokens or simplify the requested output.`
-    );
-    var createInvalidStructuredOutputError = (label) => new Error(
-      `${label} did not produce valid structured output. The model returned text instead of the expected JSON payload. This often happens when output is truncated or the provider does not follow JSON mode. Increase maxOutputTokens or simplify the requested output.`
-    );
-    var parseReasonOutputWithSchema = (args) => {
-      const candidate = resolveOutputCandidate(args.text);
-      try {
-        return parseWithSchema(args.schema, candidate, args.label);
-      } catch (error) {
-        if (args.finishReason?.unified === "length" || isLikelyTruncatedStructuredOutput(args.text)) {
-          throw createTruncatedStructuredOutputError(args.label);
-        }
-        if (typeof candidate === "string" && candidate.trim().length > 0) {
-          throw createInvalidStructuredOutputError(args.label);
-        }
-        throw error;
+    var resolveTextDeltaFieldPaths = (cfg) => {
+      const fields = cfg?.fields;
+      if (!fields) return [];
+      const textPaths = Object.entries(fields).filter(([, mode]) => mode === "text-delta").map(([path]) => path);
+      for (const path of textPaths) {
+        assertStructuredPath(path, "useReason structured text-delta");
       }
+      return textPaths;
     };
-    var parseInterruptFirstPassResult = (args) => {
-      const candidate = resolveOutputCandidate(args.text);
-      if (!isRecord22(candidate)) {
-        if (args.finishReason?.unified === "length" || isLikelyTruncatedStructuredOutput(args.text)) {
-          throw createTruncatedStructuredOutputError("useReason output");
+    var extractCompletedStringValueAt = (args) => {
+      let value = "";
+      for (let i = args.start; i < args.text.length; i += 1) {
+        const ch = args.text[i];
+        if (ch === void 0) break;
+        if (ch === '"') {
+          return {
+            complete: true,
+            value
+          };
         }
-        if (typeof candidate === "string" && candidate.trim().length > 0) {
-          throw createInvalidStructuredOutputError("useReason output");
+        if (ch !== "\\") {
+          value += ch;
+          continue;
         }
-        throw new Error(
-          "useReason first pass with interrupt must return a JSON object."
-        );
-      }
-      const mode = args.mode ?? "required";
-      let interruptRequired = true;
-      if (mode === "optional") {
-        if (candidate.decision !== "continue" && candidate.decision !== "interrupt") {
-          throw new Error(
-            'useReason optional interrupt first pass must include decision "continue" or "interrupt".'
-          );
+        const next = args.text[i + 1];
+        if (!next) {
+          return {
+            complete: false
+          };
         }
-        interruptRequired = candidate.decision === "interrupt";
-        if (!interruptRequired) {
-          const hasUnexpectedRequest = [
-            candidate.interruptRequest,
-            candidate.request,
-            candidate.interrupt
-          ].some((value) => value !== null && value !== void 0);
-          if (hasUnexpectedRequest) {
-            throw new Error(
-              'useReason optional interrupt first pass with decision "continue" must not include an interrupt request.'
-            );
-          }
+        if (next === '"' || next === "\\" || next === "/" || next === "b" || next === "f" || next === "n" || next === "r" || next === "t") {
+          value += next === "b" ? "\b" : next === "f" ? "\f" : next === "n" ? "\n" : next === "r" ? "\r" : next === "t" ? "	" : next;
+          i += 1;
+          continue;
         }
-      }
-      let request;
-      if (interruptRequired) {
-        const requestCandidates = [
-          candidate.interruptRequest,
-          candidate.request,
-          candidate.interrupt,
-          mode === "required" ? candidate : void 0
-        ];
-        const requestPayload = requestCandidates.find(
-          (value) => value !== null && value !== void 0
-        );
-        request = parseWithSchema(
-          args.requestSchema,
-          requestPayload,
-          "useReason interrupt.request"
-        );
-      }
-      let output;
-      if (args.outputSchema) {
-        const outputPayload = Object.hasOwn(candidate, "output") ? candidate.output : candidate;
-        try {
-          output = parseWithSchema(
-            args.outputSchema,
-            outputPayload,
-            "useReason output"
-          );
-        } catch (error) {
-          if (args.finishReason?.unified === "length" || isLikelyTruncatedStructuredOutput(args.text)) {
-            throw createTruncatedStructuredOutputError("useReason output");
-          }
-          if (typeof outputPayload === "string" && outputPayload.trim().length > 0) {
-            throw createInvalidStructuredOutputError("useReason output");
+        if (next === "u") {
+          const hex = args.text.slice(i + 2, i + 6);
+          if (!/^[0-9a-fA-F]{4}$/.test(hex)) {
+            return {
+              complete: false
+            };
           }
-          throw error;
+          value += String.fromCharCode(Number.parseInt(hex, 16));
+          i += 5;
+          continue;
         }
-      }
-      const explicitDraft = typeof candidate.draftText === "string" && candidate.draftText.length > 0 ? candidate.draftText : typeof candidate.text === "string" && candidate.text.length > 0 ? candidate.text : void 0;
-      if (!args.outputSchema && !explicitDraft) {
-        throw new Error(
-          "useReason first pass with interrupt requires `draftText` when outputSchema is not provided."
-        );
-      }
-      const draftText = explicitDraft ?? (output !== void 0 ? tryStringify(output) : String(args.text ?? ""));
-      if (!interruptRequired) {
         return {
-          draftText,
-          interruptRequired: false,
-          ...output !== void 0 ? { output } : {}
+          complete: false
         };
       }
       return {
-        draftText,
-        interruptRequired: true,
-        request,
-        ...output !== void 0 ? { output } : {}
+        complete: false
       };
     };
-    var import_zod5 = require("zod");
-    var tryStringify2 = (value) => {
-      if (typeof value === "string") return value;
-      try {
-        return JSON.stringify(value, null, 2);
-      } catch {
-        return String(value);
-      }
-    };
-    var tryGetSchemaHint = (schema) => {
-      try {
-        const hint = (0, import_zod5.toJSONSchema)(schema);
-        return JSON.stringify(hint, null, 2);
-      } catch {
-        return void 0;
-      }
-    };
-    var withSchemaHint = (input, label, schema) => {
-      const hint = tryGetSchemaHint(schema);
-      if (!hint) return input;
-      return `${input}
-
-${label}:
-${hint}`;
-    };
-    var defaultInterruptFirstPassInput = (args) => {
-      const mode = args.mode ?? "required";
-      const base = mode === "optional" ? args.outputSchema ? [
-        args.input,
-        "Output rules:",
-        "- Return JSON only. No markdown fences.",
-        "- Return an object with keys: decision, output, interruptRequest, draftText.",
-        '- decision must be either "continue" or "interrupt".',
-        '- Use decision "continue" when you can produce the final output without asking the user.',
-        '- Use decision "interrupt" only when user input is needed before finalizing.',
-        "- output must match the expected output JSON schema.",
-        '- When decision is "interrupt", interruptRequest must match the expected interrupt request JSON schema and must be a non-null object.',
-        '- When decision is "continue", interruptRequest must be null.',
-        "- draftText should be a concise plain-language summary of output."
-      ].join("\n\n") : [
-        args.input,
-        "Output rules:",
-        "- Return JSON only. No markdown fences.",
-        "- Return an object with keys: decision, draftText, interruptRequest.",
-        '- decision must be either "continue" or "interrupt".',
-        '- Use decision "continue" when you can produce the final answer without asking the user.',
-        '- Use decision "interrupt" only when user input is needed before finalizing.',
-        "- draftText should be the current answer text.",
-        '- When decision is "interrupt", interruptRequest must match the expected interrupt request JSON schema and must be a non-null object.',
-        '- When decision is "continue", interruptRequest must be null.'
-      ].join("\n\n") : args.outputSchema ? [
-        args.input,
-        "Output rules:",
-        "- Return JSON only. No markdown fences.",
-        "- Return an object with keys: output, interruptRequest, draftText.",
-        "- output must match the expected output JSON schema.",
-        "- interruptRequest must match the expected interrupt request JSON schema.",
-        "- interruptRequest must be a non-null object.",
-        "- draftText should be a concise plain-language summary of output.",
-        "- If uncertain, still return a valid interruptRequest with safe default options."
-      ].join("\n\n") : [
-        args.input,
-        "Output rules:",
-        "- Return JSON only. No markdown fences.",
-        "- Return an object with keys: draftText, interruptRequest.",
-        "- draftText should be the current draft answer text.",
-        "- interruptRequest must match the expected interrupt request JSON schema.",
-        "- interruptRequest must be a non-null object.",
-        "- If uncertain, still return a valid interruptRequest with safe default options."
-      ].join("\n\n");
-      const withInterruptSchema = withSchemaHint(
-        base,
-        "Expected interrupt request JSON schema (for `interruptRequest`)",
-        args.requestSchema
-      );
-      if (!args.outputSchema) return withInterruptSchema;
-      const withOutputSchema = withSchemaHint(
-        withInterruptSchema,
-        "Expected output JSON schema (for `output`)",
-        args.outputSchema
-      );
-      return [
-        withOutputSchema,
-        "JSON template:",
-        mode === "optional" ? '{ "decision": "continue", "output": { ... }, "interruptRequest": null, "draftText": "..." }' : '{ "output": { ... }, "interruptRequest": { ... }, "draftText": "..." }'
-      ].join("\n\n");
-    };
-    var defaultContinuationInput = (args) => [
-      "You are continuing a paused reasoning task after user input.",
-      "Update the previous result using the user response and return the final answer only.",
-      "If the previous output was JSON, return JSON in the same schema.",
-      "",
-      `Original request:
-${args.input}`,
-      `Draft answer text:
-${args.draftText}`,
-      `Draft output object:
-${tryStringify2(args.draftOutput ?? args.draftText)}`,
-      `Interrupt request shown to user:
-${tryStringify2(args.request)}`,
-      `User response:
-${tryStringify2(args.response)}`
-    ].join("\n\n");
-    var withOutputGuardrails = (input, schema) => {
-      const base = [
-        input,
-        "Output rules:",
-        "- Return only JSON, no markdown fences.",
-        "- Ensure the response conforms to the expected output schema.",
-        "- Do not include explanatory text outside the JSON object."
-      ].join("\n\n");
-      return withSchemaHint(base, "Expected output JSON schema", schema);
-    };
-    var withStructuredStreamHints = (input, args) => {
-      const rules = [];
-      for (const path of args.setFieldPaths ?? []) {
-        rules.push(
-          `- For the field path pattern \`${path}\`, write one stable final value and do not rewrite it after it is complete.`
-        );
-      }
-      for (const path of args.appendFieldPaths ?? []) {
-        rules.push(
-          `- For the array field path pattern \`${path}\`, write items in final order and finish each item before starting the next.`
-        );
-        rules.push(
-          `- Once an item in \`${path}\` is complete, do not rewrite or reorder earlier items.`
-        );
-      }
-      for (const path of args.textDeltaFieldPaths ?? []) {
-        rules.push(
-          `- For the string field path pattern \`${path}\`, write the value progressively by appending text to the end.`
-        );
-        rules.push(
-          `- Do not rewrite or replace the earlier prefix of \`${path}\` once emitted.`
-        );
-      }
-      if (rules.length === 0) return input;
-      return [
-        input,
-        "Streaming rules:",
-        ...rules,
-        "- Keep the overall response as valid JSON."
-      ].join("\n\n");
-    };
-    var mergeUsage = (left, right) => {
-      if (!left) return right;
-      if (!right) return left;
-      const sum = (a, b) => a === void 0 && b === void 0 ? void 0 : (a ?? 0) + (b ?? 0);
-      const raw = left.raw || right.raw ? {
-        ...left.raw ?? {},
-        ...right.raw ?? {}
-      } : void 0;
-      const input = sum(left.input, right.input);
-      const output = sum(left.output, right.output);
-      const total = sum(left.total, right.total);
-      const reasoning = sum(left.reasoning, right.reasoning);
-      const cacheRead = sum(left.cacheRead, right.cacheRead);
-      const cacheWrite = sum(left.cacheWrite, right.cacheWrite);
-      const merged = {};
-      if (input !== void 0) merged.input = input;
-      if (output !== void 0) merged.output = output;
-      if (total !== void 0) merged.total = total;
-      if (reasoning !== void 0) merged.reasoning = reasoning;
-      if (cacheRead !== void 0) merged.cacheRead = cacheRead;
-      if (cacheWrite !== void 0) merged.cacheWrite = cacheWrite;
-      if (raw) merged.raw = raw;
-      return merged;
-    };
-    var mergeWarnings = (left, right) => {
-      if (!left?.length) return right;
-      if (!right?.length) return left;
-      const seen = /* @__PURE__ */ new Set();
-      const merged = [];
-      for (const warning of [...left, ...right]) {
-        const key = JSON.stringify(warning);
-        if (seen.has(key)) continue;
-        seen.add(key);
-        merged.push(warning);
-      }
-      return merged;
-    };
-    var mergeProviderMetadata = (left, right) => {
-      if (!left) return right;
-      if (!right) return left;
-      return {
-        ...left,
-        ...right
-      };
-    };
-    var emitReasonStructuredOutput = (args) => {
-      if (!args.emit || !shouldEmitStructured(args.structured)) return;
-      emitStructuredData({
-        dataType: args.structured?.dataType ?? "reason-output",
-        data: args.output,
-        kind: "final",
-        ...args.structured?.schemaId ? { schemaId: args.structured.schemaId } : {},
-        ...args.structured?.schemaVersion ? { schemaVersion: args.structured.schemaVersion } : {},
-        ...args.id ? { id: args.id } : {},
-        streamId: args.opId
-      });
-    };
-    var resolveAppendFieldPaths = (cfg) => {
-      const fields = cfg?.fields;
-      if (!fields) return [];
-      const appendPaths = Object.entries(fields).filter(([, mode]) => mode === "append").map(([path]) => path);
-      for (const path of appendPaths) {
-        assertStructuredPath(path, "useReason structured append");
-      }
-      return appendPaths;
-    };
-    var resolveSetFieldPaths = (cfg) => {
-      const fields = cfg?.fields;
-      if (!fields) return [];
-      const setPaths = Object.entries(fields).filter(([, mode]) => mode === "set").map(([path]) => path);
-      for (const path of setPaths) {
-        assertStructuredPath(path, "useReason structured set");
-      }
-      return setPaths;
-    };
-    var resolveTextDeltaFieldPaths = (cfg) => {
-      const fields = cfg?.fields;
-      if (!fields) return [];
-      const textPaths = Object.entries(fields).filter(([, mode]) => mode === "text-delta").map(([path]) => path);
-      for (const path of textPaths) {
-        assertStructuredPath(path, "useReason structured text-delta");
-      }
-      return textPaths;
-    };
-    var extractCompletedStringValueAt = (args) => {
-      let value = "";
-      for (let i = args.start; i < args.text.length; i += 1) {
-        const ch = args.text[i];
-        if (ch === void 0) break;
-        if (ch === '"') {
-          return {
-            complete: true,
-            value
-          };
-        }
-        if (ch !== "\\") {
-          value += ch;
-          continue;
-        }
-        const next = args.text[i + 1];
-        if (!next) {
-          return {
-            complete: false
-          };
-        }
-        if (next === '"' || next === "\\" || next === "/" || next === "b" || next === "f" || next === "n" || next === "r" || next === "t") {
-          value += next === "b" ? "\b" : next === "f" ? "\f" : next === "n" ? "\n" : next === "r" ? "\r" : next === "t" ? "	" : next;
-          i += 1;
-          continue;
-        }
-        if (next === "u") {
-          const hex = args.text.slice(i + 2, i + 6);
-          if (!/^[0-9a-fA-F]{4}$/.test(hex)) {
-            return {
-              complete: false
-            };
-          }
-          value += String.fromCharCode(Number.parseInt(hex, 16));
-          i += 5;
-          continue;
-        }
-        return {
-          complete: false
-        };
-      }
-      return {
-        complete: false
-      };
-    };
-    var skipWhitespace = (text, start) => {
-      let i = start;
-      while (i < text.length && /\s/.test(text[i] ?? "")) i += 1;
-      return i;
+    var skipWhitespace = (text, start) => {
+      let i = start;
+      while (i < text.length && /\s/.test(text[i] ?? "")) i += 1;
+      return i;
     };
     var pathSegmentMatches = (patternPart, actualPart) => patternPart === "*" || patternPart === actualPart;
     var pathMatchesPattern = (actualParts, patternParts) => actualParts.length === patternParts.length && actualParts.every(
@@ -1223,11 +978,11 @@ ${tryStringify2(args.response)}`
         args.path,
         "useReason structured field"
       );
-      const matches = [];
+      const matches2 = [];
       const visitValue = (start, currentParts) => {
         const valueStart = skipWhitespace(args.text, start);
         if (pathMatchesPattern(currentParts, targetParts)) {
-          matches.push({
+          matches2.push({
             path: currentParts.join("."),
             start: valueStart
           });
@@ -1259,7 +1014,7 @@ ${tryStringify2(args.response)}`
           const valueStart = skipWhitespace(args.text, i + 1);
           const childParts = [...currentParts, key.value];
           if (pathMatchesPattern(childParts, targetParts)) {
-            matches.push({
+            matches2.push({
               path: childParts.join("."),
               start: valueStart
             });
@@ -1286,7 +1041,7 @@ ${tryStringify2(args.response)}`
           if (args.text[i] === "]") return;
           const childParts = [...currentParts, String(index)];
           if (pathMatchesPattern(childParts, targetParts)) {
-            matches.push({
+            matches2.push({
               path: childParts.join("."),
               start: i
             });
@@ -1308,7 +1063,7 @@ ${tryStringify2(args.response)}`
         }
       };
       visitValue(0, []);
-      return matches;
+      return matches2;
     };
     var extractCompletedValueAt = (args) => {
       const start = skipWhitespace(args.text, args.start);
@@ -1572,24 +1327,473 @@ ${tryStringify2(args.response)}`
         };
       }
       return {
-        found: true,
-        complete: false,
-        value
+        found: true,
+        complete: false,
+        value
+      };
+    };
+    var extractStreamingStringValues = (args) => {
+      return locateValueStarts(args).flatMap((match) => {
+        const current = extractStreamingStringValue({
+          text: args.text,
+          path: match.path
+        });
+        return current.found ? [
+          {
+            path: match.path,
+            complete: current.complete,
+            value: current.value
+          }
+        ] : [];
+      });
+    };
+    function createStructuredOutputStreamer(args, id, opId) {
+      let firstText = "";
+      const setFieldPaths = resolveSetFieldPaths(args.structured);
+      const appendFieldPaths = resolveAppendFieldPaths(args.structured);
+      const textDeltaFieldPaths = resolveTextDeltaFieldPaths(args.structured);
+      const emittedSetValues = /* @__PURE__ */ new Map();
+      const emittedAppendCounts = /* @__PURE__ */ new Map();
+      const emittedTextValues = /* @__PURE__ */ new Map();
+      return (delta) => {
+        firstText += delta;
+        for (const fieldPath of setFieldPaths) {
+          const values = extractCompletedFieldValues({
+            text: firstText,
+            path: fieldPath
+          });
+          for (const { path, value } of values) {
+            const nextSerialized = JSON.stringify(value);
+            if (emittedSetValues.get(path) === nextSerialized) continue;
+            emittedSetValues.set(path, nextSerialized);
+            emitStructuredData({
+              kind: "set",
+              path,
+              value,
+              dataType: args.structured?.dataType ?? "reason-output",
+              ...args.structured?.schemaId ? { schemaId: args.structured.schemaId } : {},
+              ...args.structured?.schemaVersion ? { schemaVersion: args.structured.schemaVersion } : {},
+              ...id ? { id } : {},
+              streamId: opId
+            });
+          }
+        }
+        for (const fieldPath of appendFieldPaths) {
+          const groups = extractCompletedArrayItemGroups({
+            text: firstText,
+            path: fieldPath
+          });
+          for (const { path, items } of groups) {
+            const emittedAppendCount = emittedAppendCounts.get(path) ?? 0;
+            if (items.length <= emittedAppendCount) continue;
+            const nextItems = items.slice(emittedAppendCount);
+            emittedAppendCounts.set(path, items.length);
+            emitStructuredData({
+              kind: "append",
+              path,
+              items: nextItems,
+              dataType: args.structured?.dataType ?? "reason-output",
+              ...args.structured?.schemaId ? { schemaId: args.structured.schemaId } : {},
+              ...args.structured?.schemaVersion ? { schemaVersion: args.structured.schemaVersion } : {},
+              ...id ? { id } : {},
+              streamId: opId
+            });
+          }
+        }
+        for (const fieldPath of textDeltaFieldPaths) {
+          const values = extractStreamingStringValues({
+            text: firstText,
+            path: fieldPath
+          });
+          for (const { path, value } of values) {
+            const emittedTextValue = emittedTextValues.get(path) ?? "";
+            if (value.length <= emittedTextValue.length || !value.startsWith(emittedTextValue)) {
+              continue;
+            }
+            const nextDelta = value.slice(emittedTextValue.length);
+            emittedTextValues.set(path, value);
+            if (nextDelta.length === 0) continue;
+            emitStructuredData({
+              kind: "text-delta",
+              path,
+              delta: nextDelta,
+              dataType: args.structured?.dataType ?? "reason-output",
+              ...args.structured?.schemaId ? { schemaId: args.structured.schemaId } : {},
+              ...args.structured?.schemaVersion ? { schemaVersion: args.structured.schemaVersion } : {},
+              ...id ? { id } : {},
+              streamId: opId
+            });
+          }
+        }
+      };
+    }
+    var tryJsonParse = (value) => {
+      try {
+        return { ok: true, value: JSON.parse(value) };
+      } catch (error) {
+        return {
+          ok: false,
+          error: error instanceof Error ? error.message : String(error)
+        };
+      }
+    };
+    var extractJsonCodeBlock = (value) => {
+      const match = value.match(/```(?:json)?\s*([\s\S]*?)```/i);
+      if (!match || typeof match[1] !== "string") return null;
+      const inner = match[1].trim();
+      return inner.length > 0 ? inner : null;
+    };
+    var tryStringify = (value) => {
+      if (typeof value === "string") return value;
+      try {
+        return JSON.stringify(value, null, 2);
+      } catch {
+        return String(value);
+      }
+    };
+    var isRecord22 = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+    var resolveOutputCandidate = (text) => {
+      const trimmed = text.trim();
+      if (!trimmed) return text;
+      const direct = tryJsonParse(trimmed);
+      if (direct.ok) return direct.value;
+      const block = extractJsonCodeBlock(trimmed);
+      if (block) {
+        const parsedBlock = tryJsonParse(block);
+        if (parsedBlock.ok) return parsedBlock.value;
+      }
+      return text;
+    };
+    var looksLikeStructuredJsonAttempt = (value) => {
+      const trimmed = value.trim();
+      if (!trimmed) return false;
+      return trimmed.startsWith("{") || trimmed.startsWith("[") || /^```(?:json)?/i.test(trimmed);
+    };
+    var isLikelyTruncatedStructuredOutput = (text) => {
+      const trimmed = text.trim();
+      if (!looksLikeStructuredJsonAttempt(trimmed)) return false;
+      const direct = tryJsonParse(trimmed);
+      if (!direct.ok && direct.error) return true;
+      const block = extractJsonCodeBlock(trimmed);
+      if (!block) return false;
+      const parsedBlock = tryJsonParse(block);
+      return !parsedBlock.ok && Boolean(parsedBlock.error);
+    };
+    var createTruncatedStructuredOutputError = (label) => new Error(
+      `${label} was truncated before producing valid structured output. The model stopped due to output length. Increase maxOutputTokens or simplify the requested output.`
+    );
+    var createInvalidStructuredOutputError = (label) => new Error(
+      `${label} did not produce valid structured output. The model returned text instead of the expected JSON payload. This often happens when output is truncated or the provider does not follow JSON mode. Increase maxOutputTokens or simplify the requested output.`
+    );
+    var parseReasonOutputWithSchema = (args) => {
+      const candidate = resolveOutputCandidate(args.text);
+      try {
+        return parseWithSchema(args.schema, candidate, args.label);
+      } catch (error) {
+        if (args.finishReason?.unified === "length" || isLikelyTruncatedStructuredOutput(args.text)) {
+          throw createTruncatedStructuredOutputError(args.label);
+        }
+        if (typeof candidate === "string" && candidate.trim().length > 0) {
+          throw createInvalidStructuredOutputError(args.label);
+        }
+        throw error;
+      }
+    };
+    var parseInterruptFirstPassResult = (args) => {
+      const candidate = resolveOutputCandidate(args.text);
+      if (!isRecord22(candidate)) {
+        if (args.finishReason?.unified === "length" || isLikelyTruncatedStructuredOutput(args.text)) {
+          throw createTruncatedStructuredOutputError("useReason output");
+        }
+        if (typeof candidate === "string" && candidate.trim().length > 0) {
+          throw createInvalidStructuredOutputError("useReason output");
+        }
+        throw new Error(
+          "useReason first pass with interrupt must return a JSON object."
+        );
+      }
+      const mode = args.mode ?? "required";
+      let interruptRequired = true;
+      if (mode === "optional") {
+        if (candidate.decision !== "continue" && candidate.decision !== "interrupt") {
+          throw new Error(
+            'useReason optional interrupt first pass must include decision "continue" or "interrupt".'
+          );
+        }
+        interruptRequired = candidate.decision === "interrupt";
+        if (!interruptRequired) {
+          const hasUnexpectedRequest = [
+            candidate.interruptRequest,
+            candidate.request,
+            candidate.interrupt
+          ].some((value) => value !== null && value !== void 0);
+          if (hasUnexpectedRequest) {
+            throw new Error(
+              'useReason optional interrupt first pass with decision "continue" must not include an interrupt request.'
+            );
+          }
+        }
+      }
+      let request;
+      if (interruptRequired) {
+        const requestCandidates = [
+          candidate.interruptRequest,
+          candidate.request,
+          candidate.interrupt,
+          mode === "required" ? candidate : void 0
+        ];
+        const requestPayload = requestCandidates.find(
+          (value) => value !== null && value !== void 0
+        );
+        request = parseWithSchema(
+          args.requestSchema,
+          requestPayload,
+          "useReason interrupt.request"
+        );
+      }
+      let output;
+      if (args.outputSchema) {
+        const outputPayload = Object.hasOwn(candidate, "output") ? candidate.output : candidate;
+        try {
+          output = parseWithSchema(
+            args.outputSchema,
+            outputPayload,
+            "useReason output"
+          );
+        } catch (error) {
+          if (args.finishReason?.unified === "length" || isLikelyTruncatedStructuredOutput(args.text)) {
+            throw createTruncatedStructuredOutputError("useReason output");
+          }
+          if (typeof outputPayload === "string" && outputPayload.trim().length > 0) {
+            throw createInvalidStructuredOutputError("useReason output");
+          }
+          throw error;
+        }
+      }
+      const explicitDraft = typeof candidate.draftText === "string" && candidate.draftText.length > 0 ? candidate.draftText : typeof candidate.text === "string" && candidate.text.length > 0 ? candidate.text : void 0;
+      if (!args.outputSchema && !explicitDraft) {
+        throw new Error(
+          "useReason first pass with interrupt requires `draftText` when outputSchema is not provided."
+        );
+      }
+      const draftText = explicitDraft ?? (output !== void 0 ? tryStringify(output) : String(args.text ?? ""));
+      if (!interruptRequired) {
+        return {
+          draftText,
+          interruptRequired: false,
+          ...output !== void 0 ? { output } : {}
+        };
+      }
+      return {
+        draftText,
+        interruptRequired: true,
+        request,
+        ...output !== void 0 ? { output } : {}
+      };
+    };
+    var import_zod32 = require("zod");
+    var tryStringify2 = (value) => {
+      if (typeof value === "string") return value;
+      try {
+        return JSON.stringify(value, null, 2);
+      } catch {
+        return String(value);
+      }
+    };
+    var tryGetSchemaHint = (schema) => {
+      try {
+        const hint = (0, import_zod32.toJSONSchema)(schema);
+        return JSON.stringify(hint, null, 2);
+      } catch {
+        return void 0;
+      }
+    };
+    var withSchemaHint = (input, label, schema) => {
+      const hint = tryGetSchemaHint(schema);
+      if (!hint) return input;
+      return `${input}
+
+${label}:
+${hint}`;
+    };
+    var defaultInterruptFirstPassInput = (args) => {
+      const mode = args.mode ?? "required";
+      const base = mode === "optional" ? args.outputSchema ? [
+        args.input,
+        "Output rules:",
+        "- Return JSON only. No markdown fences.",
+        "- Return an object with keys: decision, output, interruptRequest, draftText.",
+        '- decision must be either "continue" or "interrupt".',
+        '- Use decision "continue" when you can produce the final output without asking the user.',
+        '- Use decision "interrupt" only when user input is needed before finalizing.',
+        "- output must match the expected output JSON schema.",
+        '- When decision is "interrupt", interruptRequest must match the expected interrupt request JSON schema and must be a non-null object.',
+        '- When decision is "continue", interruptRequest must be null.',
+        "- draftText should be a concise plain-language summary of output."
+      ].join("\n\n") : [
+        args.input,
+        "Output rules:",
+        "- Return JSON only. No markdown fences.",
+        "- Return an object with keys: decision, draftText, interruptRequest.",
+        '- decision must be either "continue" or "interrupt".',
+        '- Use decision "continue" when you can produce the final answer without asking the user.',
+        '- Use decision "interrupt" only when user input is needed before finalizing.',
+        "- draftText should be the current answer text.",
+        '- When decision is "interrupt", interruptRequest must match the expected interrupt request JSON schema and must be a non-null object.',
+        '- When decision is "continue", interruptRequest must be null.'
+      ].join("\n\n") : args.outputSchema ? [
+        args.input,
+        "Output rules:",
+        "- Return JSON only. No markdown fences.",
+        "- Return an object with keys: output, interruptRequest, draftText.",
+        "- output must match the expected output JSON schema.",
+        "- interruptRequest must match the expected interrupt request JSON schema.",
+        "- interruptRequest must be a non-null object.",
+        "- draftText should be a concise plain-language summary of output.",
+        "- If uncertain, still return a valid interruptRequest with safe default options."
+      ].join("\n\n") : [
+        args.input,
+        "Output rules:",
+        "- Return JSON only. No markdown fences.",
+        "- Return an object with keys: draftText, interruptRequest.",
+        "- draftText should be the current draft answer text.",
+        "- interruptRequest must match the expected interrupt request JSON schema.",
+        "- interruptRequest must be a non-null object.",
+        "- If uncertain, still return a valid interruptRequest with safe default options."
+      ].join("\n\n");
+      const withInterruptSchema = withSchemaHint(
+        base,
+        "Expected interrupt request JSON schema (for `interruptRequest`)",
+        args.requestSchema
+      );
+      if (!args.outputSchema) return withInterruptSchema;
+      const withOutputSchema = withSchemaHint(
+        withInterruptSchema,
+        "Expected output JSON schema (for `output`)",
+        args.outputSchema
+      );
+      return [
+        withOutputSchema,
+        "JSON template:",
+        mode === "optional" ? '{ "decision": "continue", "output": { ... }, "interruptRequest": null, "draftText": "..." }' : '{ "output": { ... }, "interruptRequest": { ... }, "draftText": "..." }'
+      ].join("\n\n");
+    };
+    var defaultContinuationInput = (args) => [
+      "You are continuing a paused reasoning task after user input.",
+      "Update the previous result using the user response and return the final answer only.",
+      "If the previous output was JSON, return JSON in the same schema.",
+      "",
+      `Original request:
+${args.input}`,
+      `Draft answer text:
+${args.draftText}`,
+      `Draft output object:
+${tryStringify2(args.draftOutput ?? args.draftText)}`,
+      `Interrupt request shown to user:
+${tryStringify2(args.request)}`,
+      `User response:
+${tryStringify2(args.response)}`
+    ].join("\n\n");
+    var withOutputGuardrails = (input, schema) => {
+      const base = [
+        input,
+        "Output rules:",
+        "- Return only JSON, no markdown fences.",
+        "- Ensure the response conforms to the expected output schema.",
+        "- Do not include explanatory text outside the JSON object."
+      ].join("\n\n");
+      return withSchemaHint(base, "Expected output JSON schema", schema);
+    };
+    var withStructuredStreamHints = (input, args) => {
+      const rules = [];
+      for (const path of args.setFieldPaths ?? []) {
+        rules.push(
+          `- For the field path pattern \`${path}\`, write one stable final value and do not rewrite it after it is complete.`
+        );
+      }
+      for (const path of args.appendFieldPaths ?? []) {
+        rules.push(
+          `- For the array field path pattern \`${path}\`, write items in final order and finish each item before starting the next.`
+        );
+        rules.push(
+          `- Once an item in \`${path}\` is complete, do not rewrite or reorder earlier items.`
+        );
+      }
+      for (const path of args.textDeltaFieldPaths ?? []) {
+        rules.push(
+          `- For the string field path pattern \`${path}\`, write the value progressively by appending text to the end.`
+        );
+        rules.push(
+          `- Do not rewrite or replace the earlier prefix of \`${path}\` once emitted.`
+        );
+      }
+      if (rules.length === 0) return input;
+      return [
+        input,
+        "Streaming rules:",
+        ...rules,
+        "- Keep the overall response as valid JSON."
+      ].join("\n\n");
+    };
+    var mergeUsage = (left, right) => {
+      if (!left) return right;
+      if (!right) return left;
+      const sum = (a, b) => a === void 0 && b === void 0 ? void 0 : (a ?? 0) + (b ?? 0);
+      const raw = left.raw || right.raw ? {
+        ...left.raw ?? {},
+        ...right.raw ?? {}
+      } : void 0;
+      const input = sum(left.input, right.input);
+      const output = sum(left.output, right.output);
+      const total = sum(left.total, right.total);
+      const reasoning = sum(left.reasoning, right.reasoning);
+      const cacheRead = sum(left.cacheRead, right.cacheRead);
+      const cacheWrite = sum(left.cacheWrite, right.cacheWrite);
+      const merged = {
+        ...right.outputIncludesReasoning !== void 0 ? { outputIncludesReasoning: right.outputIncludesReasoning } : {},
+        ...right.inputIncludesCacheWrite !== void 0 ? { inputIncludesCacheWrite: right.inputIncludesCacheWrite } : {},
+        ...right.inputIncludesCacheRead !== void 0 ? { inputIncludesCacheRead: right.inputIncludesCacheRead } : {}
+      };
+      if (input !== void 0) merged.input = input;
+      if (output !== void 0) merged.output = output;
+      if (total !== void 0) merged.total = total;
+      if (reasoning !== void 0) merged.reasoning = reasoning;
+      if (cacheRead !== void 0) merged.cacheRead = cacheRead;
+      if (cacheWrite !== void 0) merged.cacheWrite = cacheWrite;
+      if (raw) merged.raw = raw;
+      return merged;
+    };
+    var mergeWarnings = (left, right) => {
+      if (!left?.length) return right;
+      if (!right?.length) return left;
+      const seen = /* @__PURE__ */ new Set();
+      const merged = [];
+      for (const warning of [...left, ...right]) {
+        const key = JSON.stringify(warning);
+        if (seen.has(key)) continue;
+        seen.add(key);
+        merged.push(warning);
+      }
+      return merged;
+    };
+    var mergeProviderMetadata = (left, right) => {
+      if (!left) return right;
+      if (!right) return left;
+      return {
+        ...left,
+        ...right
       };
     };
-    var extractStreamingStringValues = (args) => {
-      return locateValueStarts(args).flatMap((match) => {
-        const current = extractStreamingStringValue({
-          text: args.text,
-          path: match.path
-        });
-        return current.found ? [
-          {
-            path: match.path,
-            complete: current.complete,
-            value: current.value
-          }
-        ] : [];
+    var emitReasonStructuredOutput = (args) => {
+      if (!args.emit || !shouldEmitStructured(args.structured)) return;
+      emitStructuredData({
+        dataType: args.structured?.dataType ?? "reason-output",
+        data: args.output,
+        kind: "final",
+        ...args.structured?.schemaId ? { schemaId: args.structured.schemaId } : {},
+        ...args.structured?.schemaVersion ? { schemaVersion: args.structured.schemaVersion } : {},
+        ...args.id ? { id: args.id } : {},
+        streamId: args.opId
       });
     };
     var import_core42 = require("@kortyx/core");
@@ -1644,13 +1848,16 @@ ${tryStringify2(args.response)}`
       { role: "user", content: String(args.input ?? "") }
     ];
     var runReasonToolLoop = async (args) => {
-      const { useReasonArgs, id, opId, traceSpan } = args;
+      const { useReasonArgs, id, traceSpan, checkpointKey } = args;
       const ctx = getHookContext();
       const abortSignal = (0, import_core42.combineAbortSignals)(
         ctx.node.abortSignal,
         useReasonArgs.abortSignal,
         useReasonArgs.model.options?.abortSignal
       );
+      const saved = ctx.currentNodeState.byKey[checkpointKey];
+      const checkpoint = saved?.status === "tool_loop" ? saved : void 0;
+      const opId = checkpoint?.opId ?? args.opId;
       const tools = useReasonArgs.tools ?? [];
       const toolByName = /* @__PURE__ */ new Map();
       let validationCompleted = false;
@@ -1676,20 +1883,43 @@ ${tryStringify2(args.response)}`
       }
       const toolDefinitions = toToolDefinitions(tools);
       const maxSteps = Math.max(1, useReasonArgs.toolExecution?.maxSteps ?? 3);
-      const messages = createInitialMessages({
+      const messages = checkpoint?.messages ?? createInitialMessages({
         system: useReasonArgs.system,
-        input: useReasonArgs.input
+        input: useReasonArgs.outputSchema ? withOutputGuardrails(useReasonArgs.input, useReasonArgs.outputSchema) : useReasonArgs.input
       });
-      const steps = [];
-      const allToolCalls = [];
-      const allToolResults = [];
+      const steps = checkpoint?.steps ?? [];
+      const allToolCalls = steps.flatMap(
+        (step) => step.toolCalls
+      );
+      const allToolResults = steps.flatMap(
+        (step) => step.toolResults
+      );
       let finalText = "";
       let finalRaw;
       let finalOutput;
-      let aggregatedUsage;
+      let aggregatedUsage = steps.reduce(
+        (usage, step) => mergeUsage(usage, step.usage),
+        void 0
+      );
       let finalFinishReason;
       let aggregatedProviderMetadata;
-      let aggregatedWarnings;
+      let aggregatedWarnings = steps.reduce(
+        (warnings, step) => mergeWarnings(warnings, step.warnings),
+        args.initialWarnings
+      );
+      let pending = checkpoint?.pending;
+      const approvedCalls = checkpoint?.approvedCalls ?? [];
+      const save = () => {
+        ctx.currentNodeState.byKey[checkpointKey] = {
+          status: "tool_loop",
+          opId,
+          messages,
+          steps,
+          approvedCalls,
+          ...pending ? { pending } : {}
+        };
+        ctx.stateDirty = true;
+      };
       const emitToolEvent = (event, payload) => {
         ctx.node.emit(event, {
           ...payload,
@@ -1699,26 +1929,43 @@ ${tryStringify2(args.response)}`
         });
       };
       try {
-        for (let stepIndex = 0; stepIndex < maxSteps; stepIndex += 1) {
+        for (let stepIndex = pending ? steps.length - 1 : steps.length; stepIndex < maxSteps; stepIndex += 1) {
           (0, import_core42.throwIfExecutionAborted)(abortSignal);
           traceSpan?.addEvent?.("useReason.tool-step.start", {
             stepIndex,
             toolCount: toolDefinitions.length
           });
-          const step = await reasonEngine(
+          const reused = Boolean(pending);
+          const stream = useReasonArgs.stream ?? useReasonArgs.model.options?.streaming ?? true;
+          const emit = useReasonArgs.emit ?? true;
+          let textStarted = false;
+          const structuredChunk = useReasonArgs.outputSchema && stream && emit && shouldStreamStructured(useReasonArgs.structured) ? createStructuredOutputStreamer(useReasonArgs, id, opId) : void 0;
+          const step = pending ?? await reasonEngine(
             {
               ...useReasonArgs,
               tools: toolDefinitions,
               messages,
               emit: false,
-              stream: false
+              stream,
+              onTextChunk: (delta) => {
+                if (structuredChunk) structuredChunk(delta);
+                if (!emit || useReasonArgs.outputSchema || !delta) return;
+                if (!textStarted) {
+                  emitToolEvent("text-start", {});
+                  textStarted = true;
+                }
+                emitToolEvent("text-delta", { delta });
+              }
             },
             { ...id ? { id } : {}, opId }
           );
+          if (textStarted) emitToolEvent("text-end", {});
           finalText = step.text;
           finalRaw = step.raw;
-          aggregatedUsage = mergeUsage(aggregatedUsage, step.usage);
-          accumulateTokenUsage(step.usage);
+          if (!reused) {
+            aggregatedUsage = mergeUsage(aggregatedUsage, step.usage);
+            accumulateTokenUsage(step.usage);
+          }
           finalFinishReason = step.finishReason;
           aggregatedProviderMetadata = mergeProviderMetadata(
             aggregatedProviderMetadata,
@@ -1726,32 +1973,35 @@ ${tryStringify2(args.response)}`
           );
           aggregatedWarnings = mergeWarnings(aggregatedWarnings, step.warnings);
           const toolCalls = step.toolCalls ?? [];
-          const toolResults = [];
-          steps.push({
-            stepIndex,
-            text: step.text,
-            toolCalls,
-            toolResults,
-            ...step.usage ? { usage: step.usage } : {},
-            ...step.finishReason ? { finishReason: step.finishReason } : {},
-            ...step.providerMetadata ? { providerMetadata: step.providerMetadata } : {},
-            ...step.warnings ? { warnings: step.warnings } : {}
-          });
+          const toolResults = reused ? steps[stepIndex]?.toolResults ?? [] : [];
+          if (!reused)
+            steps.push({
+              stepIndex,
+              text: step.text,
+              toolCalls,
+              toolResults,
+              ...step.usage ? { usage: step.usage } : {},
+              ...step.finishReason ? { finishReason: step.finishReason } : {},
+              ...step.providerMetadata ? { providerMetadata: step.providerMetadata } : {},
+              ...step.warnings ? { warnings: step.warnings } : {}
+            });
           if (toolCalls.length === 0) {
-            if ((useReasonArgs.emit ?? true) && step.text.length > 0) {
-              emitToolEvent("text-start", {});
-              emitToolEvent("text-delta", { delta: step.text });
-              emitToolEvent("text-end", {});
-            }
             break;
           }
-          allToolCalls.push(...toolCalls);
-          messages.push({
-            role: "assistant",
-            content: step.text,
-            toolCalls
-          });
+          if (!reused) {
+            allToolCalls.push(...toolCalls);
+            messages.push({
+              role: "assistant",
+              content: step.text,
+              toolCalls,
+              ...step.continuation ? { continuation: step.continuation } : {}
+            });
+          }
+          pending = step;
+          save();
           for (const toolCall of toolCalls) {
+            if (toolResults.some((result2) => result2.toolCallId === toolCall.id))
+              continue;
             (0, import_core42.throwIfExecutionAborted)(abortSignal);
             const tool = toolByName.get(toolCall.name);
             if (!tool) {
@@ -1781,7 +2031,7 @@ ${tryStringify2(args.response)}`
                 input: toolCall.input
               });
             }
-            if (shouldApproveTool) {
+            if (shouldApproveTool && !approvedCalls.includes(toolCall.id)) {
               const approval = await awaitInterruptInternal({
                 id: `tool:${toolCall.id}`,
                 request: {
@@ -1816,8 +2066,18 @@ ${tryStringify2(args.response)}`
                     isError: true
                   });
                 }
+                messages.push({
+                  role: "tool",
+                  content: denied.content,
+                  toolCallId: denied.toolCallId,
+                  name: denied.name,
+                  isError: true
+                });
+                save();
                 continue;
               }
+              approvedCalls.push(toolCall.id);
+              save();
             }
             try {
               (0, import_core42.throwIfExecutionAborted)(abortSignal);
@@ -1871,25 +2131,19 @@ ${tryStringify2(args.response)}`
                 message: result2.content
               });
             }
+            const completed = toolResults.at(-1);
+            if (completed)
+              messages.push({
+                role: "tool",
+                content: completed.content,
+                toolCallId: completed.toolCallId,
+                name: completed.name,
+                ...completed.isError !== void 0 ? { isError: completed.isError } : {}
+              });
+            save();
           }
-          const currentStep = steps[steps.length - 1];
-          if (currentStep) {
-            steps[steps.length - 1] = {
-              ...currentStep,
-              toolResults
-            };
-          }
-          for (const result2 of toolResults) {
-            messages.push({
-              role: "tool",
-              content: result2.content,
-              toolCallId: result2.toolCallId,
-              name: result2.name,
-              ...result2.structuredContent !== void 0 ? { structuredContent: result2.structuredContent } : {},
-              ...result2.isError !== void 0 ? { isError: result2.isError } : {},
-              ...result2.raw !== void 0 ? { raw: result2.raw } : {}
-            });
-          }
+          pending = void 0;
+          save();
         }
         if (steps.length >= maxSteps && steps.at(-1)?.toolCalls.length) {
           throw new Error(
@@ -1943,6 +2197,8 @@ ${tryStringify2(args.response)}`
             output: useReasonArgs.telemetry?.output ?? finalOutput ?? finalText
           }
         });
+        ctx.currentNodeState.byKey[checkpointKey] = { status: "completed", result };
+        ctx.stateDirty = true;
         return result;
       } catch (error) {
         traceSpan?.fail?.(error, {
@@ -1976,7 +2232,15 @@ ${tryStringify2(args.response)}`
         args.model.options?.abortSignal
       );
       (0, import_core52.throwIfExecutionAborted)(abortSignal);
-      args = { ...args, abortSignal };
+      const inferred = inferOutputFormat(
+        args.outputSchema,
+        args.responseFormat ?? args.model.options?.responseFormat
+      );
+      args = {
+        ...args,
+        abortSignal,
+        ...!args.interrupt && inferred.responseFormat ? { responseFormat: inferred.responseFormat } : {}
+      };
       const id = typeof args.id === "string" && args.id.length > 0 ? args.id : void 0;
       const opId = createRuntimeId2();
       const checkpointKey = resolveReasonCheckpointKey({
@@ -2020,6 +2284,8 @@ ${tryStringify2(args.response)}`
       if (args.tools?.length) {
         return runReasonToolLoop({
           useReasonArgs: args,
+          checkpointKey,
+          initialWarnings: inferred.warnings,
           ...id ? { id } : {},
           opId,
           ...traceSpan ? { traceSpan } : {}
@@ -2043,10 +2309,7 @@ ${tryStringify2(args.response)}`
       let aggregatedUsage;
       let finalFinishReason;
       let aggregatedProviderMetadata;
-      let aggregatedWarnings;
-      const emittedSetValues = /* @__PURE__ */ new Map();
-      const emittedAppendCounts = /* @__PURE__ */ new Map();
-      const emittedTextValues = /* @__PURE__ */ new Map();
+      let aggregatedWarnings = inferred.warnings;
       if (existingCheckpoint) {
         firstText = existingCheckpoint.firstText;
         firstRaw = existingCheckpoint.firstRaw;
@@ -2068,78 +2331,7 @@ ${tryStringify2(args.response)}`
             emit: suppressTextStream ? false : args.emit,
             stream: useStructuredIncrementalStreaming ? true : suppressTextStream ? false : args.stream,
             ...useStructuredIncrementalStreaming ? {
-              onTextChunk: (delta) => {
-                firstText += delta;
-                finalText = firstText;
-                for (const fieldPath of setFieldPaths) {
-                  const values = extractCompletedFieldValues({
-                    text: firstText,
-                    path: fieldPath
-                  });
-                  for (const { path, value } of values) {
-                    const nextSerialized = JSON.stringify(value);
-                    if (emittedSetValues.get(path) === nextSerialized) continue;
-                    emittedSetValues.set(path, nextSerialized);
-                    emitStructuredData({
-                      kind: "set",
-                      path,
-                      value,
-                      dataType: args.structured?.dataType ?? "reason-output",
-                      ...args.structured?.schemaId ? { schemaId: args.structured.schemaId } : {},
-                      ...args.structured?.schemaVersion ? { schemaVersion: args.structured.schemaVersion } : {},
-                      ...id ? { id } : {},
-                      streamId: opId
-                    });
-                  }
-                }
-                for (const fieldPath of appendFieldPaths) {
-                  const groups = extractCompletedArrayItemGroups({
-                    text: firstText,
-                    path: fieldPath
-                  });
-                  for (const { path, items } of groups) {
-                    const emittedAppendCount = emittedAppendCounts.get(path) ?? 0;
-                    if (items.length <= emittedAppendCount) continue;
-                    const nextItems = items.slice(emittedAppendCount);
-                    emittedAppendCounts.set(path, items.length);
-                    emitStructuredData({
-                      kind: "append",
-                      path,
-                      items: nextItems,
-                      dataType: args.structured?.dataType ?? "reason-output",
-                      ...args.structured?.schemaId ? { schemaId: args.structured.schemaId } : {},
-                      ...args.structured?.schemaVersion ? { schemaVersion: args.structured.schemaVersion } : {},
-                      ...id ? { id } : {},
-                      streamId: opId
-                    });
-                  }
-                }
-                for (const fieldPath of textDeltaFieldPaths) {
-                  const values = extractStreamingStringValues({
-                    text: firstText,
-                    path: fieldPath
-                  });
-                  for (const { path, value } of values) {
-                    const emittedTextValue = emittedTextValues.get(path) ?? "";
-                    if (value.length <= emittedTextValue.length || !value.startsWith(emittedTextValue)) {
-                      continue;
-                    }
-                    const nextDelta = value.slice(emittedTextValue.length);
-                    emittedTextValues.set(path, value);
-                    if (nextDelta.length === 0) continue;
-                    emitStructuredData({
-                      kind: "text-delta",
-                      path,
-                      delta: nextDelta,
-                      dataType: args.structured?.dataType ?? "reason-output",
-                      ...args.structured?.schemaId ? { schemaId: args.structured.schemaId } : {},
-                      ...args.structured?.schemaVersion ? { schemaVersion: args.structured.schemaVersion } : {},
-                      ...id ? { id } : {},
-                      streamId: opId
-                    });
-                  }
-                }
-              }
+              onTextChunk: createStructuredOutputStreamer(args, id, opId)
             } : {}
           },
           reasonMeta,
@@ -2259,6 +2451,7 @@ ${tryStringify2(args.response)}`
         const second = await reasonEngine(
           {
             ...args,
+            ...inferred.responseFormat ? { responseFormat: inferred.responseFormat } : {},
             emit: suppressTextStream ? false : args.emit,
             stream: suppressTextStream ? false : args.stream
           },
@@ -2389,7 +2582,7 @@ ${tryStringify2(args.response)}`
       return [getValue(), setValue];
     }
     var import_node_crypto5 = require("crypto");
-    var import_core6 = require("@kortyx/core");
+    var import_core62 = require("@kortyx/core");
     var import_node_crypto42 = require("crypto");
     function emitWorkflowCall2(telemetry, type, payload) {
       const base = telemetry?.correlation;
@@ -2472,7 +2665,7 @@ ${tryStringify2(args.response)}`
     }
     async function useWorkflow(args) {
       const ctx = getHookContext();
-      (0, import_core6.throwIfExecutionAborted)(ctx.node.abortSignal);
+      (0, import_core62.throwIfExecutionAborted)(ctx.node.abortSignal);
       const service = ctx.node.callWorkflow;
       if (!service)
         throw new Error("useWorkflow requires an agent workflow registry.");
@@ -2577,9 +2770,9 @@ ${tryStringify2(args.response)}`
               ...record.interrupts.length ? { response: record.interrupts.at(-1)?.response } : {}
             });
           } catch (error) {
-            (0, import_core6.throwIfExecutionAborted)(ctx.node.abortSignal);
-            if ((0, import_core6.isExecutionCancelled)(error)) throw error;
-            if ((0, import_core6.isExecutionLimitReached)(error)) {
+            (0, import_core62.throwIfExecutionAborted)(ctx.node.abortSignal);
+            if ((0, import_core62.isExecutionCancelled)(error)) throw error;
+            if ((0, import_core62.isExecutionLimitReached)(error)) {
               const child = error;
               if (child.__kortyxChildSnapshot)
                 record.snapshot = child.__kortyxChildSnapshot;
@@ -2595,7 +2788,7 @@ ${tryStringify2(args.response)}`
             report("failed", { error: "Child workflow failed" });
             throw new WorkflowCallError(workflow, record.error);
           }
-          (0, import_core6.throwIfExecutionAborted)(ctx.node.abortSignal);
+          (0, import_core62.throwIfExecutionAborted)(ctx.node.abortSignal);
           recordUsage(outcome.usage);
           if (outcome.status === "completed") {
             record.data = outcome.data;
@@ -2719,6 +2912,7 @@ function parseCheckpointRequestBody(value) {
 async function handleChatRequestBody(args) {
   const { agent, body } = args;
   const stream = await agent.streamChat(body.messages, {
+    ...args.onExecution ? { onExecution: args.onExecution } : {},
     ...args.abortSignal ? { abortSignal: args.abortSignal } : {},
     sessionId: body.sessionId,
     workflowId: body.workflowId,
@@ -2742,7 +2936,8 @@ function createChatRouteHandler(args) {
       return await handleChatRequestBody({
         agent,
         body,
-        abortSignal: request.signal
+        abortSignal: request.signal,
+        onExecution: args.onExecution
       });
     } catch (error) {
       return new Response(
@@ -2809,23 +3004,23 @@ async function* streamChatFromRoute(args) {
 
 // src/chat/create-agent.ts
 var import_node_path = require("path");
-var import_core4 = require("@kortyx/core");
+var import_core5 = require("@kortyx/core");
 var import_providers = require("@kortyx/providers");
 var import_runtime5 = require("@kortyx/runtime");
-var import_zod4 = require("zod");
+var import_zod5 = require("zod");
 
 // src/execution/execute.ts
-var import_core3 = require("@kortyx/core");
+var import_core4 = require("@kortyx/core");
 var import_runtime3 = require("@kortyx/runtime");
 var import_zod3 = require("zod");
 
 // src/interrupt/resume-handler.ts
-var import_core2 = require("@kortyx/core");
+var import_core3 = require("@kortyx/core");
 var import_runtime2 = require("@kortyx/runtime");
 
 // src/orchestrator.ts
 var import_node_stream = require("stream");
-var import_core = require("@kortyx/core");
+var import_core2 = require("@kortyx/core");
 var import_runtime = require("@kortyx/runtime");
 var import_langgraph = require("@langchain/langgraph");
 
@@ -2907,6 +3102,47 @@ async function validateExecutionOutput(state, select) {
   return { ...state, data };
 }
 
+// src/stream/response-lifecycle.ts
+var import_core = require("@kortyx/core");
+function createResponseLifecycle(args) {
+  const controller = new AbortController();
+  let closed = args.restored;
+  let completing;
+  const abort = () => controller.abort();
+  const detachRequest = () => args.requestSignal?.removeEventListener("abort", abort);
+  if (!closed) {
+    args.requestSignal?.addEventListener("abort", abort, { once: true });
+    if (args.requestSignal?.aborted) abort();
+  }
+  args.executionSignal?.addEventListener("abort", abort, { once: true });
+  if (args.executionSignal?.aborted) abort();
+  return {
+    get closed() {
+      return closed;
+    },
+    signal: controller.signal,
+    disconnect() {
+      if (!closed) abort();
+    },
+    dispose() {
+      detachRequest();
+      args.executionSignal?.removeEventListener("abort", abort);
+    },
+    complete(options, state) {
+      if (!args.enabled || closed) return Promise.resolve();
+      completing ??= (async () => {
+        (0, import_core.throwIfExecutionAborted)(controller.signal);
+        await args.finalize(options, state);
+        (0, import_core.throwIfExecutionAborted)(controller.signal);
+        closed = true;
+        detachRequest();
+        args.onClosed();
+      })();
+      return completing;
+    }
+  };
+}
+
 // src/stream/transform-graph-stream-for-ui.ts
 var isGraphStateOutput = (value) => value !== null && typeof value === "object" && !Array.isArray(value) && "currentWorkflow" in value;
 async function* transformGraphStreamForUI(stream, options = {}) {
@@ -3263,6 +3499,8 @@ async function orchestrateGraphStream({
   state,
   config: initialConfig,
   abortSignal: requestSignal,
+  executionSignal,
+  onExecution,
   emitOutput = true,
   onOutcome,
   selectWorkflow,
@@ -3271,20 +3509,88 @@ async function orchestrateGraphStream({
 }) {
   const out = new import_node_stream.PassThrough({ objectMode: true });
   const write = (chunk) => {
-    if (emitOutput && !out.destroyed) out.write(chunk);
+    if (emitOutput && !response.closed && !out.destroyed) out.write(chunk);
   };
   let outcomeState = state;
   let outcomeError;
-  let sessionCheckpointId;
+  let sessionCheckpointId = initialConfig.responseCheckpointId;
   let config = initialConfig;
   const budget = config.executionBudget;
   let currentGraph = graph;
   let currentState = state;
   let finished = false;
-  const controller = new AbortController();
-  const abortSignal = (0, import_core.combineAbortSignals)(requestSignal, controller.signal);
+  const response = createResponseLifecycle({
+    enabled: emitOutput,
+    restored: initialConfig.responseCompleted === true,
+    requestSignal,
+    executionSignal,
+    onClosed: () => {
+      out.write({ type: "done" });
+      out.end();
+    },
+    finalize: async (options, nodeState) => {
+      const snapshot = JSON.parse(JSON.stringify(nodeState));
+      delete snapshot.config.responseCompleted;
+      delete snapshot.config.responseCheckpointId;
+      if (options.message !== void 0) {
+        forwardEmit("message", {
+          node: nodeState.lastNode,
+          content: options.message
+        });
+      }
+      if (options.data !== void 0) {
+        forwardEmit("structured_data", {
+          node: nodeState.lastNode,
+          data: options.data
+        });
+      }
+      if (sessionId && frameworkAdapter) {
+        const checkpoint = await frameworkAdapter.sessionCheckpoints.append({
+          sessionId,
+          runId,
+          workflow: String(snapshot.currentWorkflow),
+          state: snapshot,
+          nodes: [...touchedNodes],
+          structuredStreamIds: [...structuredStreamIds],
+          pendingRequests: []
+        });
+        sessionCheckpointId = checkpoint.id;
+        write({
+          type: "checkpoint",
+          id: checkpoint.id,
+          sessionId,
+          turnIndex: checkpoint.turnIndex
+        });
+        emitTelemetryEvent({
+          config,
+          type: "session.checkpointed",
+          payload: {
+            checkpointId: checkpoint.id,
+            turnIndex: checkpoint.turnIndex,
+            nodes: checkpoint.nodes
+          }
+        });
+      }
+      (0, import_core2.throwIfExecutionAborted)(abortSignal);
+      config.responseCompleted = true;
+      config.responseCheckpointId = sessionCheckpointId;
+      currentState.config.responseCompleted = true;
+      nodeState.config.responseCompleted = true;
+      currentGraph.config.responseCompleted = true;
+      emitTelemetryEvent({
+        config,
+        type: "response.completed",
+        payload: {
+          nodeId: nodeState.lastNode,
+          checkpointId: sessionCheckpointId
+        },
+        flush: true
+      });
+    }
+  });
+  const abortSignal = response.signal;
   out.on("close", () => {
-    if (!finished) controller.abort();
+    if (!finished) response.disconnect();
   });
   let structuredSeq = 0;
   const debugEnabled = Boolean(config?.features?.tracing);
@@ -3370,19 +3676,22 @@ async function orchestrateGraphStream({
   const pendingStore = frameworkAdapter?.pendingRequests;
   const sealPendingSnapshots = async () => {
     if (budget) outcomeState.config.executionBudget = budget;
+    if (response.closed) outcomeState.config.responseCompleted = true;
     if (typeof frameworkAdapter?.checkpointer?.getTuple !== "function") return;
     for (const [token, request] of activePendingRequests) {
       if (budget) request.state.config.executionBudget = budget;
+      if (response.closed) request.state.config.responseCompleted = true;
       const graphSnapshot = await (0, import_runtime.captureGraphSnapshot)(
         frameworkAdapter.checkpointer,
         runId,
         request.graphCheckpointId
       );
       if (graphSnapshot) {
-        const sealed = { ...request, graphSnapshot };
+        const sealed = { ...request, graphSnapshot, ready: true };
         activePendingRequests.set(token, sealed);
         await pendingStore?.update(token, {
           graphSnapshot,
+          ready: true,
           state: request.state
         });
       }
@@ -3400,6 +3709,8 @@ async function orchestrateGraphStream({
     const isText = kind === "text";
     const record = {
       token,
+      ready: false,
+      responseCompleted: response.closed,
       requestId,
       sessionId,
       runId,
@@ -3478,6 +3789,7 @@ async function orchestrateGraphStream({
         workflowCallPath: record.schema.meta?.workflowCallPath ?? null,
         branchId: config.executionBranchId ?? runId,
         interruptId: record.requestId,
+        responseCompleted: response.closed,
         requestId: record.requestId,
         kind: record.schema.kind,
         interactionMode: record.schema.kind === "text" ? "freeform" : record.options.length > 0 ? "static-options" : record.schema.schemaId ? "dynamic-picker" : "unknown",
@@ -3687,7 +3999,7 @@ async function orchestrateGraphStream({
   };
   const runLoop = async (runTraceSpan) => {
     while (true) {
-      (0, import_core.throwIfExecutionAborted)(abortSignal);
+      (0, import_core2.throwIfExecutionAborted)(abortSignal);
       let workflowFinalState = null;
       let workflowFinalGraphCheckpointId;
       let sawWorkflowDone = false;
@@ -3695,6 +4007,7 @@ async function orchestrateGraphStream({
       currentGraph.execution ??= {};
       currentGraph.execution.abortSignal = abortSignal;
       currentGraph.execution.budget = budget;
+      currentGraph.execution.completeResponse = response.complete;
       currentGraph.config = currentGraph.config || {};
       currentGraph.config.emit = forwardEmit;
       currentGraph.config.executionRunId = runId;
@@ -3792,7 +4105,7 @@ async function orchestrateGraphStream({
         workflowFinalGraphCheckpointId = graphSnapshot?.checkpointId;
         workflowFinalState = isGraphState(workflowDoneData) ? workflowDoneData : graphSnapshot?.state ?? currentState;
       }
-      (0, import_core.throwIfExecutionAborted)(abortSignal);
+      (0, import_core2.throwIfExecutionAborted)(abortSignal);
       const transitionTo = pending.to;
       const transitionPayload = pending.payload;
       const sourceNodeId = pending.sourceNodeId;
@@ -3857,8 +4170,8 @@ async function orchestrateGraphStream({
           currentGraph = nextGraph;
           continue;
         } catch (err) {
-          (0, import_core.throwIfExecutionAborted)(abortSignal);
-          if ((0, import_core.isExecutionCancelled)(err)) throw err;
+          (0, import_core2.throwIfExecutionAborted)(abortSignal);
+          if ((0, import_core2.isExecutionCancelled)(err)) throw err;
           outcomeError = err;
           runTraceSpan.fail?.(err);
           runTraceSpan.addEvent?.("kortyx.transition.error", {
@@ -3932,7 +4245,7 @@ async function orchestrateGraphStream({
         runTraceSpan.end?.(runTraceEndArgs());
         const resolvedSessionId2 = config?.session?.id || sessionId || "";
         await sealPendingSnapshots();
-        if (resolvedSessionId2 && frameworkAdapter?.sessionCheckpoints) {
+        if (!response.closed && resolvedSessionId2 && frameworkAdapter?.sessionCheckpoints) {
           try {
             const checkpoint = await frameworkAdapter.sessionCheckpoints.append(
               {
@@ -4003,7 +4316,7 @@ async function orchestrateGraphStream({
       }
       const resolvedSessionId = config?.session?.id || sessionId || "";
       await sealPendingSnapshots();
-      if (resolvedSessionId && frameworkAdapter?.sessionCheckpoints) {
+      if (!response.closed && resolvedSessionId && frameworkAdapter?.sessionCheckpoints) {
         try {
           const checkpoint = await frameworkAdapter.sessionCheckpoints.append({
             sessionId: resolvedSessionId,
@@ -4087,7 +4400,7 @@ async function orchestrateGraphStream({
     } catch (cleanupError) {
       console.error("[cancel:cleanupRun]", cleanupError);
     }
-    outcomeError = (0, import_core.createExecutionCancelledError)();
+    outcomeError = (0, import_core2.createExecutionCancelledError)();
     fallbackRunSpan?.setAttributes?.({ "kortyx.run.cancelled": true });
     fallbackRunSpan?.end?.();
     write({ type: "cancelled", runId, reason: "Execution cancelled." });
@@ -4095,15 +4408,15 @@ async function orchestrateGraphStream({
     finished = true;
     out.end();
   };
-  runPromise.catch(async (err) => {
-    if (abortSignal?.aborted || (0, import_core.isExecutionCancelled)(err)) {
+  const completion = runPromise.catch(async (err) => {
+    if (abortSignal?.aborted || (0, import_core2.isExecutionCancelled)(err)) {
       await finishCancelled();
       return;
     }
-    if ((0, import_core.isExecutionLimitReached)(err)) {
+    if ((0, import_core2.isExecutionLimitReached)(err)) {
       try {
         const snapshot = frameworkAdapter && await (0, import_runtime.captureGraphSnapshot)(frameworkAdapter.checkpointer, runId);
-        (0, import_core.throwIfExecutionAborted)(abortSignal);
+        (0, import_core2.throwIfExecutionAborted)(abortSignal);
         if (!snapshot)
           throw new Error(
             "Execution limit reached without a resumable checkpoint."
@@ -4145,46 +4458,50 @@ async function orchestrateGraphStream({
           }
         });
         await Promise.all(pendingRequestWrites);
-        (0, import_core.throwIfExecutionAborted)(abortSignal);
+        (0, import_core2.throwIfExecutionAborted)(abortSignal);
         if (outcomeError) throw outcomeError;
         const request = activePendingRequests.get(pendingRecordToken);
         const sealed = {
           ...request,
           state: pausedState,
           graphCheckpointId: snapshot.checkpoint.id,
-          graphSnapshot: snapshot
+          graphSnapshot: snapshot,
+          ready: true
         };
         activePendingRequests.set(request.token, sealed);
         await pendingStore?.update(request.token, sealed);
-        const checkpoint = await frameworkAdapter.sessionCheckpoints.append({
-          sessionId,
-          runId,
-          graphCheckpointId: snapshot.checkpoint.id,
-          workflow: String(pausedState.currentWorkflow),
-          state: pausedState,
-          nodes: Array.from(touchedNodes),
-          structuredStreamIds: Array.from(structuredStreamIds),
-          pendingRequests: [sealed],
-          label: "Execution limit reached"
-        });
-        (0, import_core.throwIfExecutionAborted)(abortSignal);
-        sessionCheckpointId = checkpoint.id;
-        write({
-          type: "checkpoint",
-          id: checkpoint.id,
-          sessionId: checkpoint.sessionId,
-          turnIndex: checkpoint.turnIndex,
-          label: checkpoint.label
-        });
-        emitTelemetryEvent({
-          config,
-          type: "session.checkpointed",
-          payload: {
-            checkpointId: checkpoint.id,
+        if (response.closed) pausedState.config.responseCompleted = true;
+        if (!response.closed) {
+          const checkpoint = await frameworkAdapter.sessionCheckpoints.append({
+            sessionId,
+            runId,
+            graphCheckpointId: snapshot.checkpoint.id,
+            workflow: String(pausedState.currentWorkflow),
+            state: pausedState,
+            nodes: Array.from(touchedNodes),
+            structuredStreamIds: Array.from(structuredStreamIds),
+            pendingRequests: [sealed],
+            label: "Execution limit reached"
+          });
+          (0, import_core2.throwIfExecutionAborted)(abortSignal);
+          sessionCheckpointId = checkpoint.id;
+          write({
+            type: "checkpoint",
+            id: checkpoint.id,
+            sessionId: checkpoint.sessionId,
             turnIndex: checkpoint.turnIndex,
-            nodes: checkpoint.nodes
-          }
-        });
+            label: checkpoint.label
+          });
+          emitTelemetryEvent({
+            config,
+            type: "session.checkpointed",
+            payload: {
+              checkpointId: checkpoint.id,
+              turnIndex: checkpoint.turnIndex,
+              nodes: checkpoint.nodes
+            }
+          });
+        }
         fallbackRunSpan?.setAttributes?.({
           "kortyx.run.awaiting_human_input": true,
           "kortyx.run.limit_reached": limitReached.limit
@@ -4195,7 +4512,7 @@ async function orchestrateGraphStream({
         out.end();
         return;
       } catch (pauseError) {
-        if (abortSignal?.aborted || (0, import_core.isExecutionCancelled)(pauseError)) {
+        if (abortSignal?.aborted || (0, import_core2.isExecutionCancelled)(pauseError)) {
           await finishCancelled();
           return;
         }
@@ -4220,6 +4537,7 @@ async function orchestrateGraphStream({
     finished = true;
     out.end();
   }).finally(() => {
+    response.dispose();
     onOutcome?.({
       state: outcomeState,
       pending: pendingRecordToken ? activePendingRequests.get(pendingRecordToken) : void 0,
@@ -4227,6 +4545,8 @@ async function orchestrateGraphStream({
       ...outcomeError ? { error: outcomeError } : {}
     });
   });
+  onExecution?.(completion);
+  if (response.closed) out.end();
   return out;
 }
 
@@ -4258,6 +4578,8 @@ function parseResumeMeta(msg) {
 async function tryPrepareResumeStream({
   limits,
   abortSignal,
+  executionSignal,
+  onExecution,
   lastMessage,
   meta: suppliedMeta,
   emitOutput,
@@ -4286,11 +4608,11 @@ async function tryPrepareResumeStream({
   await validatePending?.(pending);
   const isLimitPause = Boolean(pending.schema.meta?.__kortyxExecutionLimit);
   const savedBudget = pending.state?.config?.executionBudget;
-  const resumedBudget = savedBudget && isLimitPause && !meta.cancel ? (0, import_core2.restartExecutionBudget)(savedBudget, limits) : savedBudget;
+  const resumedBudget = savedBudget && isLimitPause && !meta.cancel ? (0, import_core3.restartExecutionBudget)(savedBudget, limits) : savedBudget;
   if (abortSignal?.aborted) {
     onOutcome?.({
       state: pending.state,
-      error: (0, import_core2.createExecutionCancelledError)()
+      error: (0, import_core3.createExecutionCancelledError)()
     });
     return (async function* () {
       yield {
@@ -4351,6 +4673,10 @@ async function tryPrepareResumeStream({
     const telemetryConfig = prepareWorkflowTelemetry({
       config: {
         ...config,
+        ...pending.responseCompleted ? {
+          responseCompleted: true,
+          responseCheckpointId: pending.state?.config?.responseCheckpointId
+        } : {},
         ...resumedBudget ? { executionBudget: resumedBudget } : {},
         ...pending.state?.config?.context ? { context: pending.state.config.context } : {},
         ...pending.state?.config?.executionContract ? { executionContract: pending.state.config.executionContract } : {},
@@ -4427,6 +4753,8 @@ async function tryPrepareResumeStream({
     });
     const args = {
       abortSignal,
+      executionSignal: pending.responseCompleted && emitOutput === false ? abortSignal : executionSignal,
+      onExecution,
       emitOutput,
       onOutcome,
       sessionId,
@@ -4470,14 +4798,14 @@ var responseSchema = import_zod3.z.discriminatedUnion("type", [
   import_zod3.z.object({ type: import_zod3.z.literal("cancel") }).strict()
 ]);
 function resultFromOutcome(outcome, runId, sessionId) {
-  const usage = outcome.pending?.schema.meta?.__kortyxResumeStatePatch?.tokenUsage ?? outcome.state.runtime?.tokenUsage;
+  const usage = outcome.pending?.schema.meta?.__kortyxResumeStatePatch?.tokenUsage ?? outcome.error?.__kortyxHookStatePatch?.tokenUsage ?? outcome.state.runtime?.tokenUsage;
   const info = {
     runId,
     sessionId,
     ...outcome.checkpointId ? { checkpointId: outcome.checkpointId } : {},
     ...usage ? { usage } : {}
   };
-  if ((0, import_core3.isExecutionCancelled)(outcome.error))
+  if ((0, import_core4.isExecutionCancelled)(outcome.error))
     return { ...info, status: "cancelled", reason: "Execution cancelled." };
   if (outcome.error) {
     const error = outcome.error;
@@ -4554,7 +4882,7 @@ async function executeWorkflow(services, args) {
     config: {
       ...runtimeConfig(services, sessionId, args.context),
       ...services.limits || args.limits ? {
-        executionBudget: (0, import_core3.createExecutionBudget)(
+        executionBudget: (0, import_core4.createExecutionBudget)(
           services.limits,
           args.limits
         )
@@ -4575,7 +4903,7 @@ async function executeWorkflow(services, args) {
   return new Promise((resolve2) => {
     const onOutcome = (outcome) => resolve2(resultFromOutcome(outcome, runId, sessionId));
     void (async () => {
-      (0, import_core3.throwIfExecutionAborted)(args.abortSignal);
+      (0, import_core4.throwIfExecutionAborted)(args.abortSignal);
       const graph = await (0, import_runtime3.createExecutionGraph)(workflow, config);
       await orchestrateGraphStream({
         graph,
@@ -4670,6 +4998,98 @@ async function resumeWorkflow(services, args) {
   });
 }
 
+// src/interrupt/discovery.ts
+var import_zod4 = require("zod");
+var scopeSchema = import_zod4.z.object({
+  sessionId: import_zod4.z.string().min(1).optional(),
+  runId: import_zod4.z.string().min(1).optional(),
+  context: import_zod4.z.record(
+    import_zod4.z.string(),
+    import_zod4.z.union([import_zod4.z.string(), import_zod4.z.number(), import_zod4.z.boolean(), import_zod4.z.null()])
+  ).optional()
+}).strict().refine(
+  (scope) => Boolean(
+    scope.sessionId || scope.runId || Object.keys(scope.context ?? {}).length
+  ),
+  "Interrupt discovery requires an authorized session, run, or context scope."
+);
+var matches = (record, scope) => record.ready !== false && Date.now() < record.createdAt + record.ttlMs && (!scope.sessionId || record.sessionId === scope.sessionId) && (!scope.runId || record.runId === scope.runId) && Object.entries(scope.context ?? {}).every(
+  ([key, value]) => record.state?.config.context?.[key] === value
+);
+var summary = (record) => {
+  const { meta: _meta, ...input } = record.schema;
+  const contract = record.state?.config.executionContract;
+  return {
+    id: record.requestId,
+    status: "pending",
+    runId: record.runId,
+    sessionId: record.sessionId ?? "",
+    workflow: contract?.id ?? record.workflow,
+    node: record.node,
+    createdAt: new Date(record.createdAt).toISOString(),
+    expiresAt: new Date(record.createdAt + record.ttlMs).toISOString(),
+    afterResponseCompleted: record.responseCompleted === true,
+    input: {
+      ...input,
+      options: record.options.map(({ id, label, description }) => ({
+        id,
+        label,
+        ...description !== void 0 ? { description } : {}
+      }))
+    }
+  };
+};
+function createInterruptDiscovery(store) {
+  const records = () => {
+    if (!store.list)
+      throw new Error(
+        "This persistence adapter does not support interrupt discovery; implement pendingRequests.list."
+      );
+    return store.list();
+  };
+  return {
+    async listInterrupts(options) {
+      const {
+        status: _status,
+        afterResponseCompleted,
+        ...scope
+      } = import_zod4.z.object({
+        sessionId: import_zod4.z.string().optional(),
+        runId: import_zod4.z.string().optional(),
+        context: import_zod4.z.record(
+          import_zod4.z.string(),
+          import_zod4.z.union([import_zod4.z.string(), import_zod4.z.number(), import_zod4.z.boolean(), import_zod4.z.null()])
+        ).optional(),
+        status: import_zod4.z.literal("pending").optional(),
+        afterResponseCompleted: import_zod4.z.boolean().optional()
+      }).strict().parse(options);
+      scopeSchema.parse(scope);
+      return (await records()).filter(
+        (record) => matches(record, scope) && (afterResponseCompleted === void 0 || record.responseCompleted === true === afterResponseCompleted)
+      ).sort(
+        (a, b) => a.createdAt - b.createdAt || a.requestId.localeCompare(b.requestId)
+      ).map(summary);
+    },
+    async getInterrupt(id, scope) {
+      import_zod4.z.string().min(1).parse(id);
+      scopeSchema.parse(scope);
+      const record = (await records()).find(
+        (record2) => record2.requestId === id && matches(record2, scope)
+      );
+      if (!record) return null;
+      return {
+        ...summary(record),
+        resume: {
+          token: record.token,
+          requestId: record.requestId,
+          sessionId: record.sessionId ?? "",
+          runId: record.runId
+        }
+      };
+    }
+  };
+}
+
 // src/telemetry/workflow-call-branch.ts
 var import_node_crypto3 = require("crypto");
 var import_hooks = __toESM(require_dist());
@@ -4742,6 +5162,8 @@ function extractLatestUserMessage(messages) {
 async function streamChat({
   messages,
   abortSignal,
+  executionSignal,
+  onExecution,
   options,
   sessionId,
   defaultWorkflowId,
@@ -4789,6 +5211,8 @@ async function streamChat({
   }
   const resumeStream = await tryPrepareResumeStream({
     abortSignal,
+    executionSignal,
+    onExecution,
     lastMessage: last,
     sessionId: resolvedSessionId,
     config: runtimeConfig2,
@@ -4860,6 +5284,8 @@ async function streamChat({
   };
   const orchestratedStream = await orchestrateGraphStream({
     abortSignal,
+    executionSignal,
+    onExecution,
     sessionId: resolvedSessionId,
     runId,
     graph,
@@ -4873,22 +5299,26 @@ async function streamChat({
 }
 
 // src/chat/create-agent.ts
-var agentProcessOptionsSchema = import_zod4.z.object({
-  limits: import_core4.ExecutionLimitsSchema.optional(),
-  abortSignal: import_zod4.z.custom((value) => value instanceof AbortSignal).optional(),
-  sessionId: import_zod4.z.string().optional(),
-  workflowId: import_zod4.z.string().optional(),
-  context: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()).optional()
+var agentProcessOptionsSchema = import_zod5.z.object({
+  executionSignal: import_zod5.z.custom((value) => value instanceof AbortSignal).optional(),
+  onExecution: import_zod5.z.custom(
+    (value) => typeof value === "function"
+  ).optional(),
+  limits: import_core5.ExecutionLimitsSchema.optional(),
+  abortSignal: import_zod5.z.custom((value) => value instanceof AbortSignal).optional(),
+  sessionId: import_zod5.z.string().optional(),
+  workflowId: import_zod5.z.string().optional(),
+  context: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.unknown()).optional()
 }).strict();
-var createAgentArgsBaseSchema = import_zod4.z.object({
-  limits: import_core4.ExecutionLimitsSchema.optional(),
-  getProvider: import_zod4.z.unknown().optional(),
-  workflows: import_zod4.z.array(import_zod4.z.unknown()).optional(),
-  workflowsDir: import_zod4.z.string().optional(),
-  workflowRegistry: import_zod4.z.unknown().optional(),
-  defaultWorkflowId: import_zod4.z.string().optional(),
-  frameworkAdapter: import_zod4.z.unknown().optional(),
-  telemetry: import_zod4.z.unknown().optional()
+var createAgentArgsBaseSchema = import_zod5.z.object({
+  limits: import_core5.ExecutionLimitsSchema.optional(),
+  getProvider: import_zod5.z.unknown().optional(),
+  workflows: import_zod5.z.array(import_zod5.z.unknown()).optional(),
+  workflowsDir: import_zod5.z.string().optional(),
+  workflowRegistry: import_zod5.z.unknown().optional(),
+  defaultWorkflowId: import_zod5.z.string().optional(),
+  frameworkAdapter: import_zod5.z.unknown().optional(),
+  telemetry: import_zod5.z.unknown().optional()
 }).strict();
 var createAgentArgsSchema = createAgentArgsBaseSchema.superRefine(
   (value, ctx) => {
@@ -5018,6 +5448,8 @@ function createAgent(args) {
       ...resolvedDefaultWorkflowId ? { defaultWorkflowId: resolvedDefaultWorkflowId } : {},
       messages,
       abortSignal: parsedOptions?.abortSignal,
+      executionSignal: parsedOptions?.executionSignal,
+      onExecution: parsedOptions?.onExecution,
       options: parsedOptions,
       workflowRegistry: registry,
       ...knownWorkflowIds ? { knownWorkflowIds } : {},
@@ -5025,7 +5457,7 @@ function createAgent(args) {
       getProvider: resolvedGetProvider,
       loadRuntimeConfig: (runtimeOptions) => ({
         ...limits || runtimeOptions?.limits ? {
-          executionBudget: (0, import_core4.createExecutionBudget)(
+          executionBudget: (0, import_core5.createExecutionBudget)(
             limits,
             runtimeOptions?.limits
           )
@@ -5147,6 +5579,7 @@ function createAgent(args) {
   const execute = (async (options) => executeWorkflow(await services(), options));
   const resume = (async (options) => resumeWorkflow(await services(), options));
   return {
+    ...createInterruptDiscovery(resolvedFrameworkAdapter.pendingRequests),
     execute,
     resume,
     projectTopology,