@kortyx/agent 0.15.0 → 0.16.0

package/dist/index.js

@@ -1,7 +1,12 @@
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -12,9 +17,2554 @@ var __copyProps = (to, from, except, desc) => {
       if (!__hasOwnProp.call(to, key) && key !== except)
         __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../hooks/dist/index.js
+var require_dist = __commonJS({
+  "../hooks/dist/index.js"(exports2, module2) {
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports2 = {};
+    __export2(index_exports2, {
+      WorkflowCallError: () => WorkflowCallError,
+      createWorkflowHooks: () => createWorkflowHooks,
+      emitWorkflowCall: () => emitWorkflowCall2,
+      runWithHookContext: () => runWithHookContext,
+      useInterrupt: () => useInterrupt,
+      useNodeState: () => useNodeState,
+      useReason: () => useReason2,
+      useRuntimeContext: () => useRuntimeContext,
+      useStructuredData: () => useStructuredData,
+      useWorkflow: () => useWorkflow,
+      useWorkflowState: () => useWorkflowState,
+      workflowCallFingerprint: () => workflowCallFingerprint
+    });
+    module2.exports = __toCommonJS2(index_exports2);
+    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);
+    var normalizeNodeState = (value) => {
+      if (Array.isArray(value)) {
+        return { byIndex: [...value], byKey: {} };
+      }
+      if (isRecord5(value)) {
+        const byIndex = Array.isArray(value.byIndex) ? [...value.byIndex] : [];
+        const byKey = isRecord5(value.byKey) ? { ...value.byKey } : {};
+        return { byIndex, byKey };
+      }
+      return { byIndex: [], byKey: {} };
+    };
+    var cloneWorkflowState = (value) => isRecord5(value) ? { ...value } : {};
+    var cloneTokenUsage = (value) => {
+      if (!isRecord5(value)) return void 0;
+      const input = typeof value.input === "number" ? value.input : void 0;
+      const output = typeof value.output === "number" ? value.output : void 0;
+      const total = typeof value.total === "number" ? value.total : void 0;
+      if (input === void 0 && output === void 0 && total === void 0) {
+        return void 0;
+      }
+      return {
+        input: input ?? 0,
+        output: output ?? 0,
+        total: total ?? 0
+      };
+    };
+    var getHookRuntimeState = (state) => {
+      const runtime = state.runtime ?? {};
+      const internal = isRecord5(runtime.__kortyx) ? runtime.__kortyx : void 0;
+      const result = {};
+      if (isRecord5(internal?.nodeState)) result.nodeState = internal?.nodeState;
+      if (isRecord5(internal?.workflowState)) {
+        result.workflowState = internal?.workflowState;
+      }
+      return result;
+    };
+    var createInternalContext = (ctx) => {
+      const hookRuntimeState = getHookRuntimeState(ctx.state);
+      const nodeId = ctx.node.graph.node;
+      const storedNodeState = isRecord5(hookRuntimeState.nodeState) ? hookRuntimeState.nodeState : void 0;
+      const storedNodeId = typeof storedNodeState?.nodeId === "string" ? String(storedNodeState.nodeId) : "";
+      const storedState = storedNodeState?.state;
+      const currentNodeState = storedNodeId && storedNodeId === nodeId ? normalizeNodeState(storedState) : { byIndex: [], byKey: {} };
+      return {
+        ...ctx,
+        workflowCallActive: false,
+        workflowCallIds: /* @__PURE__ */ new Set(),
+        nodeStateIndex: 0,
+        reasonCallIndex: 0,
+        currentNodeState,
+        workflowState: cloneWorkflowState(hookRuntimeState.workflowState),
+        tokenUsage: cloneTokenUsage(ctx.state.runtime?.tokenUsage),
+        stateDirty: false,
+        runtimeDirty: false
+      };
+    };
+    var buildRuntimeStateUpdates = (ctx) => {
+      const updates = {};
+      if (ctx.stateDirty) {
+        updates.__kortyx = {
+          nodeState: {
+            nodeId: ctx.node.graph.node,
+            state: ctx.currentNodeState
+          },
+          workflowState: ctx.workflowState
+        };
+      }
+      if (ctx.runtimeDirty && ctx.tokenUsage) {
+        updates.tokenUsage = ctx.tokenUsage;
+      }
+      return Object.keys(updates).length > 0 ? updates : null;
+    };
+    var cleanupCompletedReasonCheckpoints = (ctx) => {
+      let changed = false;
+      for (const [key, value] of Object.entries(ctx.currentNodeState.byKey)) {
+        if (!key.startsWith("__useReason:")) continue;
+        if (!isRecord5(value) || value.status !== "completed") continue;
+        delete ctx.currentNodeState.byKey[key];
+        changed = true;
+      }
+      if (changed) ctx.stateDirty = true;
+    };
+    var toTokenUsageDelta = (usage) => {
+      if (!usage) return void 0;
+      const input = usage.input ?? 0;
+      const output = usage.output ?? 0;
+      const total = usage.total ?? input + output + (usage.reasoning ?? 0);
+      if (input === 0 && output === 0 && total === 0) {
+        return void 0;
+      }
+      return {
+        input,
+        output,
+        total
+      };
+    };
+    function accumulateTokenUsage(usage) {
+      const delta = toTokenUsageDelta(usage);
+      if (!delta) return;
+      const ctx = getHookContext();
+      const current = ctx.tokenUsage ?? {
+        input: 0,
+        output: 0,
+        total: 0
+      };
+      ctx.tokenUsage = {
+        input: current.input + delta.input,
+        output: current.output + delta.output,
+        total: current.total + delta.total
+      };
+      ctx.runtimeDirty = true;
+    }
+    function getReasonTraceAdapter() {
+      return getHookContext().reasonTrace;
+    }
+    async function runWithHookContext(ctx, fn) {
+      const internal = createInternalContext(ctx);
+      try {
+        const result = await storage.run(internal, fn);
+        cleanupCompletedReasonCheckpoints(internal);
+        for (const key of Object.keys(internal.currentNodeState.byKey)) {
+          if (key.startsWith("__useWorkflow:") || key === "__useWorkflowActivation") {
+            internal.currentNodeState.byKey[key] = null;
+            internal.stateDirty = true;
+          }
+        }
+        return { result, runtimeUpdates: buildRuntimeStateUpdates(internal) };
+      } catch (err) {
+        const runtimeUpdates = buildRuntimeStateUpdates(internal);
+        if (runtimeUpdates) {
+          const currentRuntime = isRecord5(internal.state.runtime) ? internal.state.runtime : {};
+          internal.state.runtime = {
+            ...currentRuntime,
+            ...runtimeUpdates
+          };
+          if (err && typeof err === "object") {
+            err.__kortyxHookStatePatch = runtimeUpdates;
+          }
+        }
+        throw err;
+      }
+    }
+    function getHookContext() {
+      const ctx = storage.getStore();
+      if (!ctx) {
+        throw new Error("Hooks can only be used while a node is executing.");
+      }
+      return ctx;
+    }
+    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;
+      const value = raw;
+      if (value.status !== "awaiting_interrupt") return void 0;
+      if (typeof value.firstText !== "string") return void 0;
+      if (!value.request || typeof value.request !== "object") return void 0;
+      return {
+        status: "awaiting_interrupt",
+        request: value.request,
+        firstText: value.firstText,
+        ...Object.hasOwn(value, "firstRaw") ? { firstRaw: value.firstRaw } : {},
+        ...Object.hasOwn(value, "firstUsage") ? { firstUsage: value.firstUsage } : {},
+        ...Object.hasOwn(value, "firstFinishReason") ? { firstFinishReason: value.firstFinishReason } : {},
+        ...Object.hasOwn(value, "firstProviderMetadata") ? {
+          firstProviderMetadata: value.firstProviderMetadata
+        } : {},
+        ...Object.hasOwn(value, "firstWarnings") ? { firstWarnings: value.firstWarnings } : {},
+        ...Object.hasOwn(value, "firstOutput") ? { firstOutput: value.firstOutput } : {}
+      };
+    };
+    var readReasonCompletedCheckpoint = (raw) => {
+      if (!raw || typeof raw !== "object") return void 0;
+      const value = raw;
+      if (value.status !== "completed") return void 0;
+      if (!value.result || typeof value.result !== "object") return void 0;
+      return {
+        status: "completed",
+        result: value.result
+      };
+    };
+    var resolveHookStatePatch = (args) => ({
+      __kortyx: {
+        nodeState: {
+          nodeId: args.nodeId,
+          state: args.currentNodeState
+        },
+        workflowState: args.workflowState
+      }
+    });
+    var parseWithSchema = (schema, value, label) => {
+      if (!schema) return value;
+      const parsed = schema.safeParse(value);
+      if (parsed.success) return parsed.data;
+      const parsedError = "error" in parsed && parsed.error ? parsed.error : void 0;
+      const reason = typeof parsedError?.message === "string" && parsedError.message.length > 0 ? parsedError.message : "invalid payload";
+      throw new Error(`${label} validation failed: ${reason}`);
+    };
+    var awaitInterruptInternal = (args) => {
+      const ctx = getHookContext();
+      const request = parseWithSchema(
+        args.requestSchema,
+        args.request,
+        "useInterrupt request"
+      );
+      const userMeta = args.meta && typeof args.meta === "object" && !Array.isArray(args.meta) ? args.meta : {};
+      const resumeStatePatch = resolveHookStatePatch({
+        nodeId: ctx.node.graph.node,
+        currentNodeState: ctx.currentNodeState,
+        workflowState: ctx.workflowState
+      });
+      const enrichedRequest = {
+        ...request,
+        ...typeof args.schemaId === "string" && args.schemaId.length > 0 ? { schemaId: args.schemaId } : {},
+        ...typeof args.schemaVersion === "string" && args.schemaVersion.length > 0 ? { schemaVersion: args.schemaVersion } : {},
+        ...typeof args.id === "string" && args.id.length > 0 ? { id: args.id } : {},
+        meta: {
+          ...userMeta,
+          __kortyxResumeStatePatch: {
+            ...resumeStatePatch,
+            ...ctx.tokenUsage ? { tokenUsage: ctx.tokenUsage } : {}
+          }
+        }
+      };
+      const raw = ctx.node.awaitInterrupt(enrichedRequest);
+      const response = parseWithSchema(
+        args.responseSchema,
+        raw,
+        "useInterrupt response"
+      );
+      return Promise.resolve(response);
+    };
+    var import_node_crypto4 = require("crypto");
+    var parseStructuredPath = (path, source) => {
+      if (path.length === 0) {
+        throw new Error(`${source} path must be a non-empty dot-separated string.`);
+      }
+      const parts = path.split(".");
+      if (parts.some((part) => part.length === 0)) {
+        throw new Error(
+          `${source} path "${path}" must not contain empty segments.`
+        );
+      }
+      return parts;
+    };
+    var assertStructuredPath = (path, source) => {
+      parseStructuredPath(path, source);
+    };
+    var createStructuredStreamId = () => {
+      try {
+        return (0, import_node_crypto4.randomUUID)();
+      } catch {
+        return `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+      }
+    };
+    var emitStructuredData = (args) => {
+      const ctx = getHookContext();
+      const streamId = typeof args.streamId === "string" && args.streamId.length > 0 ? args.streamId : createStructuredStreamId();
+      const dataType = typeof args.dataType === "string" && args.dataType.length > 0 ? args.dataType : "generic";
+      const base = {
+        node: ctx.node.graph.node,
+        streamId,
+        dataType,
+        ...typeof args.schemaId === "string" && args.schemaId.length > 0 ? { schemaId: args.schemaId } : {},
+        ...typeof args.schemaVersion === "string" && args.schemaVersion.length > 0 ? { schemaVersion: args.schemaVersion } : {},
+        ...typeof args.id === "string" && args.id.length > 0 ? { id: args.id } : {}
+      };
+      if (args.kind === "set") {
+        assertStructuredPath(args.path, "useStructuredData");
+        const value = parseWithSchema(
+          args.valueSchema,
+          args.value,
+          "useStructuredData value"
+        );
+        ctx.node.emit("structured_data", {
+          ...base,
+          kind: "set",
+          path: args.path,
+          value
+        });
+        return;
+      }
+      if (args.kind === "append") {
+        assertStructuredPath(args.path, "useStructuredData");
+        const items = args.items.map(
+          (item) => parseWithSchema(args.itemSchema, item, "useStructuredData append item")
+        );
+        ctx.node.emit("structured_data", {
+          ...base,
+          kind: "append",
+          path: args.path,
+          items
+        });
+        return;
+      }
+      if (args.kind === "text-delta") {
+        assertStructuredPath(args.path, "useStructuredData");
+        ctx.node.emit("structured_data", {
+          ...base,
+          kind: "text-delta",
+          path: args.path,
+          delta: args.delta
+        });
+        return;
+      }
+      const validated = parseWithSchema(
+        args.dataSchema,
+        args.data,
+        "useStructuredData data"
+      );
+      ctx.node.emit("structured_data", {
+        ...base,
+        kind: "final",
+        data: validated
+      });
+    };
+    var shouldEmitStructured = (cfg) => Boolean(cfg);
+    var shouldStreamStructured = (cfg) => Boolean(cfg) && (cfg?.stream ?? true);
+    var import_node_crypto32 = require("crypto");
+    var import_node_crypto22 = require("crypto");
+    var toError = (value) => value instanceof Error ? value : new Error(String(value));
+    var createRuntimeId = () => {
+      try {
+        return (0, import_node_crypto22.randomUUID)();
+      } catch {
+        return `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+      }
+    };
+    var emitNodeEvent = (emitEvent, nodeId, event, payload) => {
+      if (!emitEvent) return;
+      emitEvent(event, {
+        ...payload,
+        ...typeof nodeId === "string" && nodeId.length > 0 ? { node: nodeId } : {}
+      });
+    };
+    async function runReasonEngine(args) {
+      const 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;
+      const stopSequences = args.stopSequences ?? args.model.options?.stopSequences;
+      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 tools = args.tools ?? args.model.options?.tools;
+      const model = args.model.provider.getModel(args.model.modelId, {
+        ...temperature !== void 0 ? { temperature } : {},
+        streaming: stream,
+        ...maxOutputTokens !== void 0 ? { maxOutputTokens } : {},
+        ...stopSequences !== void 0 ? { stopSequences } : {},
+        ...abortSignal !== void 0 ? { abortSignal } : {},
+        ...reasoning !== void 0 ? { reasoning } : {},
+        ...responseFormat !== void 0 ? { responseFormat } : {},
+        ...tools !== void 0 ? { tools } : {},
+        ...providerOptions !== void 0 ? { providerOptions } : {}
+      });
+      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 ?? "") }
+      ];
+      const opId = typeof args.opId === "string" && args.opId.length > 0 ? args.opId : createRuntimeId();
+      const segmentId = typeof args.segmentId === "string" && args.segmentId.length > 0 ? args.segmentId : createRuntimeId();
+      const commonMeta = {
+        ...typeof args.id === "string" && args.id.length > 0 ? { id: args.id } : {},
+        opId,
+        segmentId
+      };
+      const traceSpan = args.reasonTrace?.startSpan({
+        name: "runReasonEngine",
+        attributes: {
+          ...commonMeta,
+          providerId: args.model.provider.id,
+          modelId: args.model.modelId,
+          stream,
+          emit,
+          ...args.telemetry?.operation ? { operation: args.telemetry.operation } : {},
+          ...args.telemetry?.prompt?.name ? { promptName: args.telemetry.prompt.name } : {},
+          ...args.telemetry?.prompt?.version !== void 0 ? { promptVersion: args.telemetry.prompt.version } : {},
+          ...args.telemetry?.prompt?.type ? { promptType: args.telemetry.prompt.type } : {},
+          ...typeof args.nodeId === "string" && args.nodeId.length > 0 ? { nodeId: args.nodeId } : {}
+        },
+        telemetry: {
+          ...args.telemetry ?? {},
+          input: args.telemetry?.input ?? messages
+        }
+      });
+      const modelRequestStartedAt = Date.now();
+      let firstTextTokenAt;
+      let lastTextTokenAt;
+      const generationTimingAttributes = () => firstTextTokenAt === void 0 || lastTextTokenAt === void 0 ? {} : {
+        ttftMs: Math.max(0, firstTextTokenAt - modelRequestStartedAt),
+        streamDurationMs: Math.max(0, lastTextTokenAt - firstTextTokenAt),
+        timeToLastTokenMs: Math.max(
+          0,
+          lastTextTokenAt - modelRequestStartedAt
+        )
+      };
+      const endTrace = (span, result) => {
+        span?.end?.({
+          ...result.usage !== void 0 ? { usage: result.usage } : {},
+          ...result.finishReason !== void 0 ? { finishReason: result.finishReason } : {},
+          ...result.providerMetadata !== void 0 ? { providerMetadata: result.providerMetadata } : {},
+          ...result.warnings !== void 0 ? { warnings: result.warnings } : {},
+          attributes: {
+            textLength: result.text.length,
+            ...generationTimingAttributes()
+          },
+          telemetry: {
+            ...args.telemetry ?? {},
+            output: args.telemetry?.output ?? result.text
+          }
+        });
+      };
+      const failTrace = (span, error) => {
+        span?.fail?.(error, {
+          attributes: {
+            providerId: args.model.provider.id,
+            modelId: args.model.modelId
+          }
+        });
+      };
+      try {
+        if (stream) {
+          let final = "";
+          let raw;
+          let usage;
+          let finishReason;
+          let toolCalls;
+          let providerMetadata;
+          let warnings;
+          if (emit) {
+            emitNodeEvent(args.emitEvent, args.nodeId, "text-start", {
+              ...commonMeta
+            });
+          }
+          const response2 = await model.stream(messages);
+          for await (const chunk of response2) {
+            switch (chunk.type) {
+              case "text-delta": {
+                if (chunk.delta.length === 0) break;
+                const tokenAt = Date.now();
+                firstTextTokenAt ??= tokenAt;
+                lastTextTokenAt = tokenAt;
+                final += chunk.delta;
+                args.onTextChunk?.(chunk.delta);
+                if (chunk.raw !== void 0) {
+                  raw = chunk.raw;
+                }
+                if (chunk.providerMetadata !== void 0) {
+                  providerMetadata = chunk.providerMetadata;
+                }
+                if (emit) {
+                  emitNodeEvent(args.emitEvent, args.nodeId, "text-delta", {
+                    ...commonMeta,
+                    delta: chunk.delta
+                  });
+                }
+                break;
+              }
+              case "finish": {
+                if (chunk.raw !== void 0) {
+                  raw = chunk.raw;
+                }
+                if (chunk.usage !== void 0) {
+                  usage = chunk.usage;
+                }
+                if (chunk.finishReason !== void 0) {
+                  finishReason = chunk.finishReason;
+                }
+                if (chunk.toolCalls !== void 0) {
+                  toolCalls = chunk.toolCalls;
+                }
+                if (chunk.providerMetadata !== void 0) {
+                  providerMetadata = chunk.providerMetadata;
+                }
+                if (chunk.warnings !== void 0) {
+                  warnings = chunk.warnings;
+                }
+                break;
+              }
+              case "raw": {
+                raw = chunk.raw;
+                if (chunk.providerMetadata !== void 0) {
+                  providerMetadata = chunk.providerMetadata;
+                }
+                break;
+              }
+              case "error": {
+                if (chunk.raw !== void 0) {
+                  raw = chunk.raw;
+                }
+                if (chunk.providerMetadata !== void 0) {
+                  providerMetadata = chunk.providerMetadata;
+                }
+                if (chunk.warnings !== void 0) {
+                  warnings = chunk.warnings;
+                }
+                throw toError(chunk.error);
+              }
+            }
+          }
+          if (emit) {
+            emitNodeEvent(args.emitEvent, args.nodeId, "text-end", {
+              ...commonMeta
+            });
+          }
+          const result2 = {
+            text: final,
+            ...raw !== void 0 ? { raw } : {},
+            ...usage !== void 0 ? { usage } : {},
+            ...finishReason !== void 0 ? { finishReason } : {},
+            ...toolCalls !== void 0 ? { toolCalls } : {},
+            ...providerMetadata !== void 0 ? { providerMetadata } : {},
+            ...warnings !== void 0 ? { warnings } : {}
+          };
+          endTrace(traceSpan, result2);
+          return result2;
+        }
+        const response = await model.invoke(messages);
+        if (emit) {
+          emitNodeEvent(args.emitEvent, args.nodeId, "text-start", {
+            ...commonMeta
+          });
+          if (response.content) {
+            emitNodeEvent(args.emitEvent, args.nodeId, "text-delta", {
+              ...commonMeta,
+              delta: response.content
+            });
+          }
+          emitNodeEvent(args.emitEvent, args.nodeId, "text-end", {
+            ...commonMeta
+          });
+        }
+        const result = {
+          text: response.content,
+          ...response.raw !== void 0 ? { raw: response.raw } : {},
+          ...response.usage !== void 0 ? { usage: response.usage } : {},
+          ...response.finishReason !== void 0 ? { finishReason: response.finishReason } : {},
+          ...response.toolCalls !== void 0 ? { toolCalls: response.toolCalls } : {},
+          ...response.providerMetadata !== void 0 ? { providerMetadata: response.providerMetadata } : {},
+          ...response.warnings !== void 0 ? { warnings: response.warnings } : {}
+        };
+        endTrace(traceSpan, result);
+        return result;
+      } catch (error) {
+        failTrace(traceSpan, error);
+        throw error;
+      }
+    }
+    var createRuntimeId2 = () => {
+      try {
+        return (0, import_node_crypto32.randomUUID)();
+      } catch {
+        return `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+      }
+    };
+    async function reasonEngine(args, meta, inputOverride) {
+      const ctx = getHookContext();
+      return runReasonEngine({
+        model: args.model,
+        input: inputOverride ?? args.input,
+        system: args.system,
+        temperature: args.temperature,
+        maxOutputTokens: args.maxOutputTokens,
+        stopSequences: args.stopSequences,
+        abortSignal: args.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) };
+      } 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_zod3 = 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_zod3.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 pathSegmentMatches = (patternPart, actualPart) => patternPart === "*" || patternPart === actualPart;
+    var pathMatchesPattern = (actualParts, patternParts) => actualParts.length === patternParts.length && actualParts.every(
+      (part, index) => pathSegmentMatches(patternParts[index] ?? "", part)
+    );
+    var isPathPrefix = (prefix, full) => prefix.length <= full.length && prefix.every((part, index) => pathSegmentMatches(full[index] ?? "", part));
+    var parseStringToken = (text, start) => {
+      if (text[start] !== '"') return { complete: false };
+      const parsed = extractCompletedStringValueAt({ text, start: start + 1 });
+      if (!parsed.complete || parsed.value === void 0)
+        return { complete: false };
+      let inEscape = false;
+      for (let i = start + 1; i < text.length; i += 1) {
+        const ch = text[i];
+        if (ch === void 0) break;
+        if (inEscape) {
+          inEscape = false;
+          if (ch === "u") i += 4;
+          continue;
+        }
+        if (ch === "\\") {
+          inEscape = true;
+          continue;
+        }
+        if (ch === '"') {
+          return {
+            complete: true,
+            end: i + 1,
+            value: parsed.value
+          };
+        }
+      }
+      return { complete: false };
+    };
+    var skipNestedValue = (text, start) => {
+      const opener = text[start];
+      const closer = opener === "{" ? "}" : "]";
+      let inString = false;
+      let isEscaped = false;
+      let nesting = 0;
+      for (let i = start; i < text.length; i += 1) {
+        const ch = text[i];
+        if (ch === void 0) break;
+        if (inString) {
+          if (isEscaped) {
+            isEscaped = false;
+            continue;
+          }
+          if (ch === "\\") {
+            isEscaped = true;
+            continue;
+          }
+          if (ch === '"') {
+            inString = false;
+          }
+          continue;
+        }
+        if (ch === '"') {
+          inString = true;
+          continue;
+        }
+        if (ch === opener) {
+          nesting += 1;
+          continue;
+        }
+        if (ch === closer) {
+          nesting -= 1;
+          if (nesting === 0) {
+            return { complete: true, end: i + 1 };
+          }
+        }
+      }
+      return { complete: false };
+    };
+    var skipCompleteValue = (text, start) => {
+      const i = skipWhitespace(text, start);
+      const first = text[i];
+      if (!first) return { complete: false };
+      if (first === '"') {
+        const parsed = parseStringToken(text, i);
+        return parsed.complete && parsed.end !== void 0 ? { complete: true, end: parsed.end } : { complete: false };
+      }
+      if (first === "{" || first === "[") {
+        return skipNestedValue(text, i);
+      }
+      for (let j = i; j < text.length; j += 1) {
+        const ch = text[j];
+        if (ch !== "," && ch !== "}" && ch !== "]") continue;
+        const raw = text.slice(i, j).trim();
+        if (!raw) return { complete: false };
+        try {
+          JSON.parse(raw);
+          return { complete: true, end: j };
+        } catch {
+          return { complete: false };
+        }
+      }
+      return { complete: false };
+    };
+    var locateValueStart = (args) => {
+      const [first] = locateValueStarts(args);
+      return first ? {
+        found: true,
+        start: first.start
+      } : {
+        found: false
+      };
+    };
+    var locateValueStarts = (args) => {
+      const targetParts = parseStructuredPath(
+        args.path,
+        "useReason structured field"
+      );
+      const matches = [];
+      const visitValue = (start, currentParts) => {
+        const valueStart = skipWhitespace(args.text, start);
+        if (pathMatchesPattern(currentParts, targetParts)) {
+          matches.push({
+            path: currentParts.join("."),
+            start: valueStart
+          });
+          return;
+        }
+        if (!isPathPrefix(currentParts, targetParts)) {
+          return;
+        }
+        const first = args.text[valueStart];
+        if (first === "{") visitObject(valueStart + 1, currentParts);
+        if (first === "[") visitArray(valueStart + 1, currentParts);
+      };
+      const visitObject = (start, currentParts) => {
+        let i = skipWhitespace(args.text, start);
+        while (i < args.text.length) {
+          const ch = args.text[i];
+          if (ch === "}") return;
+          if (ch === ",") {
+            i = skipWhitespace(args.text, i + 1);
+            continue;
+          }
+          if (ch !== '"') return;
+          const key = parseStringToken(args.text, i);
+          if (!key.complete || key.end === void 0 || key.value === void 0) {
+            return;
+          }
+          i = skipWhitespace(args.text, key.end);
+          if (args.text[i] !== ":") return;
+          const valueStart = skipWhitespace(args.text, i + 1);
+          const childParts = [...currentParts, key.value];
+          if (pathMatchesPattern(childParts, targetParts)) {
+            matches.push({
+              path: childParts.join("."),
+              start: valueStart
+            });
+          } else if (isPathPrefix(childParts, targetParts)) {
+            visitValue(valueStart, childParts);
+          }
+          const skipped = skipCompleteValue(args.text, valueStart);
+          if (!skipped.complete || skipped.end === void 0) {
+            return;
+          }
+          i = skipWhitespace(args.text, skipped.end);
+          if (args.text[i] === ",") {
+            i = skipWhitespace(args.text, i + 1);
+            continue;
+          }
+          if (args.text[i] === "}") return;
+          return;
+        }
+      };
+      const visitArray = (start, currentParts) => {
+        let i = skipWhitespace(args.text, start);
+        let index = 0;
+        while (i < args.text.length) {
+          if (args.text[i] === "]") return;
+          const childParts = [...currentParts, String(index)];
+          if (pathMatchesPattern(childParts, targetParts)) {
+            matches.push({
+              path: childParts.join("."),
+              start: i
+            });
+          } else if (isPathPrefix(childParts, targetParts)) {
+            visitValue(i, childParts);
+          }
+          const skipped = skipCompleteValue(args.text, i);
+          if (!skipped.complete || skipped.end === void 0) {
+            return;
+          }
+          i = skipWhitespace(args.text, skipped.end);
+          if (args.text[i] === ",") {
+            index += 1;
+            i = skipWhitespace(args.text, i + 1);
+            continue;
+          }
+          if (args.text[i] === "]") return;
+          return;
+        }
+      };
+      visitValue(0, []);
+      return matches;
+    };
+    var extractCompletedValueAt = (args) => {
+      const start = skipWhitespace(args.text, args.start);
+      const first = args.text[start];
+      if (!first) return { complete: false };
+      if (first === '"') {
+        const parsed = extractCompletedStringValueAt({
+          text: args.text,
+          start: start + 1
+        });
+        return parsed.complete ? {
+          complete: true,
+          value: parsed.value
+        } : {
+          complete: false
+        };
+      }
+      if (first === "{") {
+        return extractCompletedNestedValueAt({
+          text: args.text,
+          start,
+          opener: "{",
+          closer: "}"
+        });
+      }
+      if (first === "[") {
+        return extractCompletedNestedValueAt({
+          text: args.text,
+          start,
+          opener: "[",
+          closer: "]"
+        });
+      }
+      for (let i = start; i < args.text.length; i += 1) {
+        const ch = args.text[i];
+        if (ch === void 0) break;
+        if (ch !== "," && ch !== "}" && ch !== "]") continue;
+        const raw = args.text.slice(start, i).trim();
+        if (!raw) return { complete: false };
+        try {
+          return {
+            complete: true,
+            value: JSON.parse(raw)
+          };
+        } catch {
+          return { complete: false };
+        }
+      }
+      return { complete: false };
+    };
+    var extractCompletedNestedValueAt = (args) => {
+      let inString = false;
+      let isEscaped = false;
+      let nesting = 0;
+      for (let i = args.start; i < args.text.length; i += 1) {
+        const ch = args.text[i];
+        if (ch === void 0) break;
+        if (inString) {
+          if (isEscaped) {
+            isEscaped = false;
+            continue;
+          }
+          if (ch === "\\") {
+            isEscaped = true;
+            continue;
+          }
+          if (ch === '"') {
+            inString = false;
+          }
+          continue;
+        }
+        if (ch === '"') {
+          inString = true;
+          continue;
+        }
+        if (ch === args.opener) {
+          nesting += 1;
+          continue;
+        }
+        if (ch === args.closer) {
+          nesting -= 1;
+          if (nesting === 0) {
+            const raw = args.text.slice(args.start, i + 1);
+            try {
+              return {
+                complete: true,
+                value: JSON.parse(raw)
+              };
+            } catch {
+              return {
+                complete: false
+              };
+            }
+          }
+        }
+      }
+      return {
+        complete: false
+      };
+    };
+    var extractCompletedFieldValues = (args) => {
+      const located = locateValueStarts(args);
+      const values = [];
+      for (const match of located) {
+        const parsed = extractCompletedValueAt({
+          text: args.text,
+          start: match.start
+        });
+        if (!parsed.complete) continue;
+        values.push({
+          path: match.path,
+          value: parsed.value
+        });
+      }
+      return values;
+    };
+    var extractCompletedArrayItems = (args) => {
+      const located = locateValueStart(args);
+      if (!located.found || located.start === void 0) return [];
+      const arrayStart = skipWhitespace(args.text, located.start);
+      if (args.text[arrayStart] !== "[") return [];
+      const start = arrayStart + 1;
+      const items = [];
+      let inString = false;
+      let isEscaped = false;
+      let nesting = 0;
+      let itemStart = -1;
+      for (let i = start; i < args.text.length; i += 1) {
+        const ch = args.text[i];
+        if (ch === void 0) break;
+        if (inString) {
+          if (isEscaped) {
+            isEscaped = false;
+            continue;
+          }
+          if (ch === "\\") {
+            isEscaped = true;
+            continue;
+          }
+          if (ch === '"') {
+            inString = false;
+          }
+          continue;
+        }
+        if (ch === '"') {
+          inString = true;
+          if (itemStart < 0) itemStart = i;
+          continue;
+        }
+        if (itemStart < 0) {
+          if (/\s/.test(ch) || ch === ",") continue;
+          if (ch === "]") break;
+          itemStart = i;
+          if (ch === "{" || ch === "[") {
+            nesting = 1;
+          } else {
+            nesting = 0;
+          }
+          continue;
+        }
+        if (ch === "{" || ch === "[") {
+          nesting += 1;
+          continue;
+        }
+        if (ch === "}" || ch === "]") {
+          if (nesting > 0) {
+            nesting -= 1;
+            continue;
+          }
+        }
+        if (nesting === 0 && (ch === "," || ch === "]")) {
+          const raw = args.text.slice(itemStart, i).trim();
+          if (raw) {
+            try {
+              items.push(JSON.parse(raw));
+            } catch {
+            }
+          }
+          itemStart = -1;
+          if (ch === "]") break;
+        }
+      }
+      return items;
+    };
+    var extractCompletedArrayItemGroups = (args) => {
+      return locateValueStarts(args).flatMap((match) => {
+        const items = extractCompletedArrayItems({
+          text: args.text,
+          path: match.path
+        });
+        return items.length > 0 ? [
+          {
+            path: match.path,
+            items
+          }
+        ] : [];
+      });
+    };
+    var extractStreamingStringValue = (args) => {
+      const located = locateValueStart(args);
+      if (!located.found || located.start === void 0) {
+        return {
+          found: located.found,
+          complete: false,
+          value: ""
+        };
+      }
+      const stringStart = skipWhitespace(args.text, located.start);
+      if (args.text[stringStart] !== '"') {
+        return {
+          found: true,
+          complete: false,
+          value: ""
+        };
+      }
+      let value = "";
+      for (let i = stringStart + 1; i < args.text.length; i += 1) {
+        const ch = args.text[i];
+        if (ch === void 0) break;
+        if (ch === '"') {
+          return {
+            found: true,
+            complete: true,
+            value
+          };
+        }
+        if (ch !== "\\") {
+          value += ch;
+          continue;
+        }
+        const next = args.text[i + 1];
+        if (!next) {
+          return {
+            found: true,
+            complete: false,
+            value
+          };
+        }
+        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 {
+              found: true,
+              complete: false,
+              value
+            };
+          }
+          value += String.fromCharCode(Number.parseInt(hex, 16));
+          i += 5;
+          continue;
+        }
+        return {
+          found: true,
+          complete: false,
+          value
+        };
+      }
+      return {
+        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
+          }
+        ] : [];
+      });
+    };
+    var toErrorMessage2 = (error) => error instanceof Error ? error.message : String(error);
+    var toToolDefinitions = (tools) => tools.map((tool) => ({
+      name: tool.name,
+      ...tool.title ? { title: tool.title } : {},
+      ...tool.description ? { description: tool.description } : {},
+      inputSchema: tool.inputSchema,
+      ...tool.outputSchema !== void 0 ? { outputSchema: tool.outputSchema } : {},
+      ...tool.annotations !== void 0 ? { annotations: tool.annotations } : {},
+      ...tool.metadata !== void 0 ? { metadata: tool.metadata } : {}
+    }));
+    var resolveToolExecutionBoolean = (value, toolName, fallback) => {
+      if (typeof value === "boolean") return value;
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        return value[toolName] ?? fallback;
+      }
+      return fallback;
+    };
+    var normalizeToolResult = (toolCall, value) => {
+      if (value && typeof value === "object" && !Array.isArray(value) && "toolCallId" in value && "name" in value && "content" in value) {
+        return value;
+      }
+      let content;
+      try {
+        content = typeof value === "string" ? value : JSON.stringify(value);
+      } catch {
+        content = String(value);
+      }
+      return {
+        toolCallId: toolCall.id,
+        name: toolCall.name,
+        content,
+        ...value !== void 0 && value !== null && typeof value === "object" && !Array.isArray(value) ? { structuredContent: value } : {}
+      };
+    };
+    var closeOwnedTools = async (tools) => {
+      const closeFns = /* @__PURE__ */ new Set();
+      for (const tool of tools) {
+        if (tool.closeAfterUse === false || !tool.close) continue;
+        closeFns.add(tool.close);
+      }
+      await Promise.all(
+        [...closeFns].map(async (close) => {
+          await close();
+        })
+      );
+    };
+    var createInitialMessages = (args) => [
+      ...typeof args.system === "string" && args.system.length > 0 ? [{ role: "system", content: args.system }] : [],
+      { role: "user", content: String(args.input ?? "") }
+    ];
+    var runReasonToolLoop = async (args) => {
+      const { useReasonArgs, id, opId, traceSpan } = args;
+      const ctx = getHookContext();
+      const tools = useReasonArgs.tools ?? [];
+      const toolByName = /* @__PURE__ */ new Map();
+      let validationCompleted = false;
+      try {
+        for (const tool of tools) {
+          if (toolByName.has(tool.name)) {
+            throw new Error(
+              `useReason received duplicate tool name "${tool.name}".`
+            );
+          }
+          toolByName.set(tool.name, tool);
+        }
+        if (useReasonArgs.interrupt) {
+          throw new Error(
+            "useReason tools cannot be combined with useReason interrupt mode yet. Use toolExecution.approval for tool approval."
+          );
+        }
+        validationCompleted = true;
+      } finally {
+        if (!validationCompleted) {
+          await closeOwnedTools(tools);
+        }
+      }
+      const toolDefinitions = toToolDefinitions(tools);
+      const maxSteps = Math.max(1, useReasonArgs.toolExecution?.maxSteps ?? 3);
+      const messages = createInitialMessages({
+        system: useReasonArgs.system,
+        input: useReasonArgs.input
+      });
+      const steps = [];
+      const allToolCalls = [];
+      const allToolResults = [];
+      let finalText = "";
+      let finalRaw;
+      let finalOutput;
+      let aggregatedUsage;
+      let finalFinishReason;
+      let aggregatedProviderMetadata;
+      let aggregatedWarnings;
+      const emitToolEvent = (event, payload) => {
+        ctx.node.emit(event, {
+          ...payload,
+          node: ctx.node.graph.node,
+          ...id ? { id } : {},
+          opId
+        });
+      };
+      try {
+        for (let stepIndex = 0; stepIndex < maxSteps; stepIndex += 1) {
+          traceSpan?.addEvent?.("useReason.tool-step.start", {
+            stepIndex,
+            toolCount: toolDefinitions.length
+          });
+          const step = await reasonEngine(
+            {
+              ...useReasonArgs,
+              tools: toolDefinitions,
+              messages,
+              emit: false,
+              stream: false
+            },
+            { ...id ? { id } : {}, opId }
+          );
+          finalText = step.text;
+          finalRaw = step.raw;
+          aggregatedUsage = mergeUsage(aggregatedUsage, step.usage);
+          finalFinishReason = step.finishReason;
+          aggregatedProviderMetadata = mergeProviderMetadata(
+            aggregatedProviderMetadata,
+            step.providerMetadata
+          );
+          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 } : {}
+          });
+          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
+          });
+          for (const toolCall of toolCalls) {
+            const tool = toolByName.get(toolCall.name);
+            if (!tool) {
+              throw new Error(
+                `Model requested unknown tool "${toolCall.name}" from useReason.`
+              );
+            }
+            const shouldEmitTool = resolveToolExecutionBoolean(
+              useReasonArgs.toolExecution?.emit,
+              tool.name,
+              false
+            );
+            const shouldApproveTool = resolveToolExecutionBoolean(
+              useReasonArgs.toolExecution?.approval,
+              tool.name,
+              false
+            );
+            traceSpan?.addEvent?.("useReason.tool-call.start", {
+              stepIndex,
+              tool: tool.name,
+              toolCallId: toolCall.id
+            });
+            if (shouldEmitTool) {
+              emitToolEvent("tool-call-start", {
+                tool: tool.name,
+                toolCallId: toolCall.id,
+                input: toolCall.input
+              });
+            }
+            if (shouldApproveTool) {
+              const approval = await awaitInterruptInternal({
+                id: `tool:${toolCall.id}`,
+                request: {
+                  kind: "choice",
+                  question: `Approve ${tool.name}?`,
+                  options: [
+                    { id: "approve", label: "Approve" },
+                    { id: "deny", label: "Deny" }
+                  ],
+                  meta: {
+                    tool: tool.name,
+                    toolCallId: toolCall.id,
+                    input: toolCall.input
+                  }
+                }
+              });
+              const approved = Array.isArray(approval) ? approval.includes("approve") : approval === "approve";
+              if (!approved) {
+                const denied = {
+                  toolCallId: toolCall.id,
+                  name: tool.name,
+                  content: "Tool call denied by user.",
+                  isError: true
+                };
+                toolResults.push(denied);
+                allToolResults.push(denied);
+                if (shouldEmitTool) {
+                  emitToolEvent("tool-call-result", {
+                    tool: tool.name,
+                    toolCallId: toolCall.id,
+                    content: denied.content,
+                    isError: true
+                  });
+                }
+                continue;
+              }
+            }
+            try {
+              const rawResult = await tool.execute(toolCall.input, {
+                toolCallId: toolCall.id,
+                ...useReasonArgs.abortSignal ? { abortSignal: useReasonArgs.abortSignal } : {}
+              });
+              const result2 = normalizeToolResult(toolCall, rawResult);
+              toolResults.push(result2);
+              allToolResults.push(result2);
+              if (shouldEmitTool) {
+                emitToolEvent("tool-call-result", {
+                  tool: result2.name,
+                  toolCallId: result2.toolCallId,
+                  content: result2.content,
+                  ...result2.structuredContent !== void 0 ? { structuredContent: result2.structuredContent } : {},
+                  ...result2.isError !== void 0 ? { isError: result2.isError } : {}
+                });
+              }
+              traceSpan?.addEvent?.("useReason.tool-call.complete", {
+                stepIndex,
+                tool: result2.name,
+                toolCallId: result2.toolCallId,
+                isError: Boolean(result2.isError)
+              });
+            } catch (error) {
+              const result2 = {
+                toolCallId: toolCall.id,
+                name: tool.name,
+                content: toErrorMessage2(error),
+                isError: true
+              };
+              toolResults.push(result2);
+              allToolResults.push(result2);
+              if (shouldEmitTool) {
+                emitToolEvent("tool-call-error", {
+                  tool: tool.name,
+                  toolCallId: toolCall.id,
+                  message: result2.content
+                });
+              }
+              traceSpan?.addEvent?.("useReason.tool-call.error", {
+                stepIndex,
+                tool: tool.name,
+                toolCallId: toolCall.id,
+                message: result2.content
+              });
+            }
+          }
+          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 } : {}
+            });
+          }
+        }
+        if (steps.length >= maxSteps && steps.at(-1)?.toolCalls.length) {
+          throw new Error(
+            `useReason tool loop reached maxSteps (${maxSteps}) before producing a final response.`
+          );
+        }
+        if (useReasonArgs.outputSchema) {
+          finalOutput = parseReasonOutputWithSchema({
+            text: finalText,
+            schema: useReasonArgs.outputSchema,
+            ...finalFinishReason ? { finishReason: finalFinishReason } : {},
+            label: "useReason output"
+          });
+        }
+        if (finalOutput !== void 0) {
+          emitReasonStructuredOutput({
+            ...id ? { id } : {},
+            opId,
+            output: finalOutput,
+            structured: useReasonArgs.structured,
+            emit: useReasonArgs.emit ?? true
+          });
+        }
+        const result = {
+          ...id ? { id } : {},
+          opId,
+          text: finalText,
+          ...finalRaw !== void 0 ? { raw: finalRaw } : {},
+          ...aggregatedUsage !== void 0 ? { usage: aggregatedUsage } : {},
+          ...finalFinishReason !== void 0 ? { finishReason: finalFinishReason } : {},
+          ...aggregatedProviderMetadata !== void 0 ? { providerMetadata: aggregatedProviderMetadata } : {},
+          ...aggregatedWarnings !== void 0 ? { warnings: aggregatedWarnings } : {},
+          ...finalOutput !== void 0 ? { output: finalOutput } : {},
+          toolCalls: allToolCalls,
+          toolResults: allToolResults,
+          steps
+        };
+        traceSpan?.end?.({
+          ...aggregatedUsage !== void 0 ? { usage: aggregatedUsage } : {},
+          ...finalFinishReason !== void 0 ? { finishReason: finalFinishReason } : {},
+          ...aggregatedProviderMetadata !== void 0 ? { providerMetadata: aggregatedProviderMetadata } : {},
+          ...aggregatedWarnings !== void 0 ? { warnings: aggregatedWarnings } : {},
+          attributes: {
+            textLength: finalText.length,
+            toolCallCount: allToolCalls.length,
+            toolResultCount: allToolResults.length,
+            toolStepCount: steps.length
+          },
+          telemetry: {
+            ...useReasonArgs.telemetry ?? {},
+            output: useReasonArgs.telemetry?.output ?? finalOutput ?? finalText
+          }
+        });
+        return result;
+      } catch (error) {
+        traceSpan?.fail?.(error, {
+          attributes: {
+            toolStepCount: steps.length,
+            toolCallCount: allToolCalls.length
+          }
+        });
+        throw error;
+      } finally {
+        await closeOwnedTools(tools);
+      }
+    };
+    var shouldStreamReasonStructured = (args) => (args.emit ?? true) && shouldStreamStructured(args.structured);
+    var resolveEffectiveReasoningIncludeThoughts = (args) => args.reasoning?.includeThoughts ?? args.model.options?.reasoning?.includeThoughts ?? false;
+    var resolveEffectiveResponseFormatType = (args) => args.responseFormat?.type ?? args.model.options?.responseFormat?.type;
+    var assertReasoningThoughtsCompatibility = (args) => {
+      if (!resolveEffectiveReasoningIncludeThoughts(args)) return;
+      const usesStructuredOutput = Boolean(args.outputSchema) || Boolean(args.interrupt) || Boolean(args.structured) || resolveEffectiveResponseFormatType(args) === "json";
+      if (!usesStructuredOutput) return;
+      throw new Error(
+        "useReason does not support reasoning.includeThoughts with structured output, interrupt mode, or JSON responseFormat. Disable includeThoughts for this call."
+      );
+    };
+    async function useReason(args) {
+      assertReasoningThoughtsCompatibility(args);
+      const ctx = getHookContext();
+      const id = typeof args.id === "string" && args.id.length > 0 ? args.id : void 0;
+      const opId = createRuntimeId2();
+      const checkpointKey = resolveReasonCheckpointKey({
+        ...id ? { id } : {},
+        autoIndex: ctx.reasonCallIndex++
+      });
+      const existingCompleted = readReasonCompletedCheckpoint(
+        ctx.currentNodeState.byKey[checkpointKey]
+      );
+      if (existingCompleted) {
+        return existingCompleted.result;
+      }
+      const existingCheckpoint = readReasonCheckpoint(
+        ctx.currentNodeState.byKey[checkpointKey]
+      );
+      const reasonMeta = typeof id === "string" ? { id, opId } : { opId };
+      const traceSpan = getReasonTraceAdapter()?.startSpan({
+        name: "useReason",
+        attributes: {
+          ...id ? { id } : {},
+          opId,
+          nodeId: ctx.node.graph.node,
+          providerId: args.model.provider.id,
+          modelId: args.model.modelId,
+          stream: args.stream ?? args.model.options?.streaming ?? true,
+          emit: args.emit ?? true,
+          ...args.telemetry?.operation ? { operation: args.telemetry.operation } : {},
+          ...args.telemetry?.prompt?.name ? { promptName: args.telemetry.prompt.name } : {},
+          ...args.telemetry?.prompt?.version !== void 0 ? { promptVersion: args.telemetry.prompt.version } : {},
+          ...args.telemetry?.prompt?.type ? { promptType: args.telemetry.prompt.type } : {},
+          hasOutputSchema: Boolean(args.outputSchema),
+          hasInterrupt: Boolean(args.interrupt),
+          hasStructured: Boolean(args.structured),
+          hasTools: Boolean(args.tools?.length)
+        },
+        telemetry: {
+          ...args.telemetry ?? {},
+          input: args.telemetry?.input ?? args.input
+        }
+      });
+      if (args.tools?.length) {
+        return runReasonToolLoop({
+          useReasonArgs: args,
+          ...id ? { id } : {},
+          opId,
+          ...traceSpan ? { traceSpan } : {}
+        });
+      }
+      const suppressTextStream = Boolean(args.outputSchema || args.interrupt);
+      const setFieldPaths = resolveSetFieldPaths(args.structured);
+      const appendFieldPaths = resolveAppendFieldPaths(args.structured);
+      const textDeltaFieldPaths = resolveTextDeltaFieldPaths(args.structured);
+      const useStructuredIncrementalStreaming = Boolean(
+        args.outputSchema && !args.interrupt && (setFieldPaths.length > 0 || appendFieldPaths.length > 0 || textDeltaFieldPaths.length > 0) && args.stream !== false && shouldStreamReasonStructured(args)
+      );
+      let firstText = "";
+      let firstRaw;
+      let firstOutput;
+      let firstInterruptRequest;
+      let firstInterruptRequired = false;
+      let finalText = "";
+      let finalRaw;
+      let finalOutput;
+      let aggregatedUsage;
+      let finalFinishReason;
+      let aggregatedProviderMetadata;
+      let aggregatedWarnings;
+      const emittedSetValues = /* @__PURE__ */ new Map();
+      const emittedAppendCounts = /* @__PURE__ */ new Map();
+      const emittedTextValues = /* @__PURE__ */ new Map();
+      if (existingCheckpoint) {
+        firstText = existingCheckpoint.firstText;
+        firstRaw = existingCheckpoint.firstRaw;
+        firstOutput = existingCheckpoint.firstOutput;
+        finalText = firstText;
+        finalRaw = firstRaw;
+        finalOutput = firstOutput;
+        aggregatedUsage = existingCheckpoint.firstUsage;
+        finalFinishReason = existingCheckpoint.firstFinishReason;
+        aggregatedProviderMetadata = existingCheckpoint.firstProviderMetadata;
+        aggregatedWarnings = existingCheckpoint.firstWarnings;
+        traceSpan?.addEvent?.("useReason.resume", {
+          checkpointKey
+        });
+      } else {
+        const first = await reasonEngine(
+          {
+            ...args,
+            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
+                    });
+                  }
+                }
+              }
+            } : {}
+          },
+          reasonMeta,
+          args.interrupt ? defaultInterruptFirstPassInput({
+            input: args.input,
+            requestSchema: args.interrupt.requestSchema,
+            mode: args.interrupt.mode ?? "required",
+            ...args.outputSchema ? { outputSchema: args.outputSchema } : {}
+          }) : args.outputSchema ? withOutputGuardrails(
+            withStructuredStreamHints(args.input, {
+              ...setFieldPaths.length > 0 ? { setFieldPaths } : {},
+              ...appendFieldPaths.length > 0 ? { appendFieldPaths } : {},
+              ...textDeltaFieldPaths.length > 0 ? { textDeltaFieldPaths } : {}
+            }),
+            args.outputSchema
+          ) : void 0
+        );
+        firstRaw = first.raw;
+        finalRaw = first.raw;
+        accumulateTokenUsage(first.usage);
+        aggregatedUsage = mergeUsage(aggregatedUsage, first.usage);
+        finalFinishReason = first.finishReason;
+        aggregatedProviderMetadata = mergeProviderMetadata(
+          aggregatedProviderMetadata,
+          first.providerMetadata
+        );
+        aggregatedWarnings = mergeWarnings(aggregatedWarnings, first.warnings);
+        traceSpan?.addEvent?.("useReason.first-pass.complete", {
+          textLength: first.text.length,
+          hasInterrupt: Boolean(args.interrupt)
+        });
+        if (args.interrupt) {
+          const firstPass = parseInterruptFirstPassResult({
+            text: first.text,
+            requestSchema: args.interrupt.requestSchema,
+            ...first.finishReason ? { finishReason: first.finishReason } : {},
+            ...args.outputSchema ? { outputSchema: args.outputSchema } : {},
+            mode: args.interrupt.mode ?? "required"
+          });
+          firstText = firstPass.draftText;
+          finalText = firstPass.draftText;
+          firstInterruptRequired = firstPass.interruptRequired;
+          firstInterruptRequest = firstPass.request;
+          firstOutput = firstPass.output;
+          finalOutput = firstPass.output;
+        } else {
+          firstText = first.text;
+          finalText = first.text;
+          if (args.outputSchema) {
+            firstOutput = parseReasonOutputWithSchema({
+              text: first.text,
+              schema: args.outputSchema,
+              ...first.finishReason ? { finishReason: first.finishReason } : {},
+              label: "useReason output"
+            });
+          }
+          finalOutput = firstOutput;
+        }
+      }
+      let interruptResponse;
+      if (args.interrupt && (existingCheckpoint || firstInterruptRequired)) {
+        const requestSchema = args.interrupt.requestSchema;
+        const interruptRequest = existingCheckpoint ? parseWithSchema(
+          requestSchema,
+          existingCheckpoint.request,
+          "useReason interrupt.request"
+        ) : firstInterruptRequest;
+        if (!interruptRequest) {
+          throw new Error(
+            "useReason interrupt request is missing; first pass did not produce a valid interrupt payload."
+          );
+        }
+        if (!existingCheckpoint) {
+          ctx.currentNodeState.byKey[checkpointKey] = {
+            status: "awaiting_interrupt",
+            request: interruptRequest,
+            firstText,
+            ...firstRaw !== void 0 ? { firstRaw } : {},
+            ...aggregatedUsage !== void 0 ? { firstUsage: aggregatedUsage } : {},
+            ...finalFinishReason !== void 0 ? { firstFinishReason: finalFinishReason } : {},
+            ...aggregatedProviderMetadata !== void 0 ? { firstProviderMetadata: aggregatedProviderMetadata } : {},
+            ...aggregatedWarnings !== void 0 ? { firstWarnings: aggregatedWarnings } : {},
+            ...firstOutput !== void 0 ? { firstOutput } : {}
+          };
+          ctx.stateDirty = true;
+        }
+        const resumeStatePatch = resolveHookStatePatch({
+          nodeId: ctx.node.graph.node,
+          currentNodeState: ctx.currentNodeState,
+          workflowState: ctx.workflowState
+        });
+        interruptResponse = await awaitInterruptInternal({
+          request: interruptRequest,
+          requestSchema,
+          responseSchema: args.interrupt.responseSchema,
+          ...args.interrupt.schemaId ? { schemaId: args.interrupt.schemaId } : {},
+          ...args.interrupt.schemaVersion ? { schemaVersion: args.interrupt.schemaVersion } : {},
+          ...id ? { id } : {},
+          meta: {
+            __kortyxResumeStatePatch: resumeStatePatch
+          }
+        });
+        traceSpan?.addEvent?.("useReason.interrupt.resolved", {
+          checkpointKey
+        });
+        if (Object.hasOwn(ctx.currentNodeState.byKey, checkpointKey)) {
+          delete ctx.currentNodeState.byKey[checkpointKey];
+          ctx.stateDirty = true;
+        }
+        const continuationInput = defaultContinuationInput({
+          input: args.input,
+          draftText: firstText,
+          ...firstOutput !== void 0 ? { draftOutput: firstOutput } : {},
+          request: interruptRequest,
+          response: interruptResponse
+        });
+        const second = await reasonEngine(
+          {
+            ...args,
+            emit: suppressTextStream ? false : args.emit,
+            stream: suppressTextStream ? false : args.stream
+          },
+          reasonMeta,
+          args.outputSchema ? withOutputGuardrails(
+            continuationInput,
+            args.outputSchema
+          ) : continuationInput
+        );
+        finalText = second.text;
+        finalRaw = second.raw;
+        accumulateTokenUsage(second.usage);
+        aggregatedUsage = mergeUsage(aggregatedUsage, second.usage);
+        finalFinishReason = second.finishReason;
+        aggregatedProviderMetadata = mergeProviderMetadata(
+          aggregatedProviderMetadata,
+          second.providerMetadata
+        );
+        aggregatedWarnings = mergeWarnings(aggregatedWarnings, second.warnings);
+        traceSpan?.addEvent?.("useReason.continuation.complete", {
+          textLength: second.text.length
+        });
+        if (args.outputSchema) {
+          finalOutput = parseReasonOutputWithSchema({
+            text: finalText,
+            schema: args.outputSchema,
+            ...second.finishReason ? { finishReason: second.finishReason } : {},
+            label: "useReason output"
+          });
+        }
+      }
+      if (finalOutput !== void 0) {
+        emitReasonStructuredOutput({
+          ...id ? { id } : {},
+          opId,
+          output: finalOutput,
+          structured: args.structured,
+          emit: args.emit ?? true
+        });
+      }
+      const result = {
+        ...id ? { id } : {},
+        opId,
+        text: finalText,
+        ...finalRaw !== void 0 ? { raw: finalRaw } : {},
+        ...aggregatedUsage !== void 0 ? { usage: aggregatedUsage } : {},
+        ...finalFinishReason !== void 0 ? { finishReason: finalFinishReason } : {},
+        ...aggregatedProviderMetadata !== void 0 ? { providerMetadata: aggregatedProviderMetadata } : {},
+        ...aggregatedWarnings !== void 0 ? { warnings: aggregatedWarnings } : {},
+        ...finalOutput !== void 0 ? { output: finalOutput } : {},
+        ...interruptResponse !== void 0 ? { interruptResponse } : {}
+      };
+      if (args.interrupt) {
+        ctx.currentNodeState.byKey[checkpointKey] = {
+          status: "completed",
+          result
+        };
+        ctx.stateDirty = true;
+      }
+      traceSpan?.end?.({
+        ...aggregatedUsage !== void 0 ? { usage: aggregatedUsage } : {},
+        ...finalFinishReason !== void 0 ? { finishReason: finalFinishReason } : {},
+        ...aggregatedProviderMetadata !== void 0 ? { providerMetadata: aggregatedProviderMetadata } : {},
+        ...aggregatedWarnings !== void 0 ? { warnings: aggregatedWarnings } : {},
+        attributes: {
+          textLength: finalText.length,
+          resumedFromCheckpoint: Boolean(existingCheckpoint),
+          interrupted: Boolean(interruptResponse !== void 0)
+        },
+        telemetry: {
+          ...args.telemetry ?? {},
+          output: args.telemetry?.output ?? finalOutput ?? finalText
+        }
+      });
+      return result;
+    }
+    function useStructuredData(args) {
+      emitStructuredData(args);
+    }
+    function useReason2(args) {
+      return useReason(args);
+    }
+    function useInterrupt(args) {
+      return awaitInterruptInternal(args);
+    }
+    function useRuntimeContext() {
+      const ctx = getHookContext();
+      const config = ctx.state.config;
+      const context = config && typeof config === "object" && "context" in config ? config.context : void 0;
+      return context && typeof context === "object" && !Array.isArray(context) ? context : {};
+    }
+    function useNodeState(initialValue) {
+      const ctx = getHookContext();
+      const nodeState = ctx.currentNodeState;
+      const index = ctx.nodeStateIndex++;
+      if (index >= nodeState.byIndex.length) {
+        nodeState.byIndex[index] = initialValue;
+        ctx.stateDirty = true;
+      }
+      const getValue = () => nodeState.byIndex[index];
+      const setValue = (next) => {
+        const prev = getValue();
+        const resolved = typeof next === "function" ? next(prev) : next;
+        nodeState.byIndex[index] = resolved;
+        ctx.stateDirty = true;
+      };
+      return [getValue(), setValue];
+    }
+    function useWorkflowState(key, ...rest) {
+      const ctx = getHookContext();
+      const workflowState = ctx.workflowState;
+      const hasInitial = rest.length > 0;
+      const initialValue = rest[0];
+      if (!Object.hasOwn(workflowState, key) && hasInitial) {
+        workflowState[key] = initialValue;
+        ctx.stateDirty = true;
+      }
+      const getValue = () => workflowState[key];
+      const setValue = (next) => {
+        const prev = getValue();
+        const resolved = typeof next === "function" ? next(prev) : next;
+        workflowState[key] = resolved;
+        ctx.stateDirty = true;
+      };
+      return [getValue(), setValue];
+    }
+    var import_node_crypto5 = require("crypto");
+    var import_node_crypto42 = require("crypto");
+    function emitWorkflowCall2(telemetry, type, payload) {
+      const base = telemetry?.correlation;
+      if (!telemetry?.reporter || !telemetry.environment || !telemetry.service || !base?.runId || !base.workflowId)
+        return;
+      try {
+        const active = telemetry.trace?.getActiveContext?.();
+        void Promise.resolve(
+          telemetry.reporter.emit([
+            {
+              schemaVersion: 1,
+              eventId: (0, import_node_crypto42.randomUUID)(),
+              occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
+              environment: telemetry.environment,
+              service: telemetry.service,
+              correlation: {
+                ...base,
+                runId: base.runId,
+                workflowId: base.workflowId,
+                ...active
+              },
+              type,
+              payload
+            }
+          ])
+        ).catch(() => {
+        });
+      } catch {
+      }
+    }
+    function workflowCallContent(telemetry, side, value) {
+      const policy = telemetry?.captureContent;
+      if (!(policy === true || policy && typeof policy === "object" && policy[side]))
+        return {};
+      const serialized = JSON.stringify(value);
+      return serialized && Buffer.byteLength(serialized, "utf8") <= 16384 ? { [side]: JSON.parse(serialized) } : { [`${side}Omitted`]: "Content exceeds 16 KiB" };
+    }
+    var WorkflowCallError = class extends Error {
+      constructor(workflow, message) {
+        super(`Workflow '${workflow}': ${message}`);
+        this.workflow = workflow;
+        this.name = "WorkflowCallError";
+      }
+      workflow;
+    };
+    function workflowCallFingerprint(value) {
+      const seen = /* @__PURE__ */ new Set();
+      const canonical = (v) => {
+        if (v === null || typeof v === "string" || typeof v === "boolean") return v;
+        if (typeof v === "number" && Number.isFinite(v)) return v;
+        if (typeof v !== "object" || !v || seen.has(v)) {
+          throw new Error("Workflow input and output must be JSON serializable.");
+        }
+        if (!Array.isArray(v) && Object.getPrototypeOf(v) !== Object.prototype) {
+          throw new Error(
+            "Workflow input and output must contain plain JSON objects."
+          );
+        }
+        seen.add(v);
+        const result = Array.isArray(v) ? v.map(canonical) : Object.fromEntries(
+          Object.keys(v).sort().map((key) => [
+            key,
+            canonical(v[key])
+          ])
+        );
+        seen.delete(v);
+        return result;
+      };
+      return JSON.stringify(canonical(value));
+    }
+    function createWorkflowHooks(workflows) {
+      return {
+        useWorkflow: (args) => {
+          const workflow = workflows[args.workflow];
+          if (!workflow || workflow.id !== args.workflow)
+            throw new Error("Workflow registry keys must match definition ids.");
+          return useWorkflow({ ...args, workflow });
+        }
+      };
+    }
+    async function useWorkflow(args) {
+      const ctx = getHookContext();
+      const service = ctx.node.callWorkflow;
+      if (!service)
+        throw new Error("useWorkflow requires an agent workflow registry.");
+      if (!args.id.trim())
+        throw new Error("useWorkflow requires a stable, nonempty id.");
+      if (ctx.workflowCallActive)
+        throw new Error(
+          "Concurrent workflow calls are not supported; await each call."
+        );
+      if (ctx.workflowCallIds.has(args.id))
+        throw new Error(
+          `Duplicate workflow call id '${args.id}' in one node activation.`
+        );
+      if (ctx.workflowCallIds.size >= 64)
+        throw new Error(
+          "A node may call at most 64 child workflows per activation."
+        );
+      ctx.workflowCallIds.add(args.id);
+      const definition = typeof args.workflow === "string" ? void 0 : args.workflow;
+      const workflow = definition?.id ?? args.workflow;
+      const input = args.input;
+      const fingerprint = workflowCallFingerprint({
+        workflow,
+        input,
+        version: definition?.version ?? null
+      });
+      const key = `__useWorkflow:${args.id}`;
+      let record = ctx.currentNodeState.byKey[key];
+      if (record && record.fingerprint !== fingerprint)
+        throw new WorkflowCallError(
+          workflow,
+          "call input or target changed during replay"
+        );
+      record ??= {
+        fingerprint,
+        invocationId: (0, import_node_crypto5.randomUUID)(),
+        status: "running",
+        interrupts: []
+      };
+      ctx.currentNodeState.byKey[key] = record;
+      ctx.stateDirty = true;
+      ctx.workflowCallActive = true;
+      const telemetry = ctx.node.workflowCallTelemetry;
+      const activationKey = "__useWorkflowActivation";
+      ctx.currentNodeState.byKey[activationKey] ??= (0, import_node_crypto5.randomUUID)();
+      const callerNodeExecutionId = ctx.currentNodeState.byKey[activationKey];
+      const metadata2 = {
+        invocationId: record.invocationId,
+        parentInvocationId: telemetry?.correlation?.invocationId ?? null,
+        branchId: telemetry?.correlation?.branchId ?? telemetry?.correlation?.runId ?? "unknown",
+        callId: args.id,
+        callerNodeId: ctx.node.graph.node,
+        callerNodeExecutionId,
+        sourceWorkflowId: ctx.node.graph.name,
+        targetWorkflowId: workflow,
+        targetVersion: definition?.version ?? null
+      };
+      record.telemetry = metadata2;
+      const report = (status, content = {}) => {
+        record.sequence = (record.sequence ?? 0) + 1;
+        emitWorkflowCall2(telemetry, `workflow.call.${status}`, {
+          ...metadata2,
+          sequence: record.sequence,
+          ...content
+        });
+      };
+      const cached = record.status === "completed";
+      try {
+        for (const interruption of record.interrupts) {
+          interruption.response = await awaitInterruptInternal({
+            request: interruption.request,
+            ...interruption.request.meta ? { meta: interruption.request.meta } : {}
+          });
+        }
+        if (record.status === "failed")
+          throw new WorkflowCallError(workflow, record.error ?? "child failed");
+        while (record.status !== "completed") {
+          let outcome;
+          try {
+            report(
+              record.snapshot ? "resumed" : "started",
+              workflowCallContent(telemetry, "input", input)
+            );
+            outcome = await service({
+              callerNodeExecutionId,
+              id: args.id,
+              workflow,
+              input,
+              definition,
+              invocationId: record.invocationId,
+              ...record.snapshot ? { snapshot: record.snapshot } : {},
+              ...record.interrupts.length ? { response: record.interrupts.at(-1)?.response } : {}
+            });
+          } catch (error) {
+            record.status = "failed";
+            record.error = error instanceof Error ? error.message : String(error);
+            report("failed", { error: "Child workflow failed" });
+            throw new WorkflowCallError(workflow, record.error);
+          }
+          if (outcome.status === "completed") {
+            record.data = outcome.data;
+            accumulateTokenUsage(outcome.usage);
+            workflowCallFingerprint(record.data);
+            record.status = "completed";
+            delete record.snapshot;
+            report(
+              "completed",
+              workflowCallContent(telemetry, "output", record.data)
+            );
+          } else {
+            record.status = "interrupted";
+            record.snapshot = outcome.snapshot;
+            report("suspended", {
+              leaf: outcome.request.meta?.workflowCall ?? null
+            });
+            const interruption = {
+              request: outcome.request
+            };
+            record.interrupts.push(interruption);
+            interruption.response = await awaitInterruptInternal({
+              request: interruption.request,
+              ...interruption.request.meta ? { meta: interruption.request.meta } : {}
+            });
+          }
+        }
+        if (cached)
+          report("reused", workflowCallContent(telemetry, "output", record.data));
+        const data = record.data ?? {};
+        return {
+          data: JSON.parse(JSON.stringify(data))
+        };
+      } finally {
+        ctx.workflowCallActive = false;
+      }
+    }
+  }
+});
 
 // src/index.ts
 var index_exports = {};
@@ -237,7 +2787,10 @@ var emitTelemetryEvent = (args) => {
       }
     } : {},
     type: args.type,
-    payload: args.payload
+    payload: {
+      ...args.payload,
+      ...args.type === "run.cancelled" ? { branchId: args.config.executionBranchId ?? runId } : {}
+    }
   };
   try {
     void Promise.resolve(telemetry.reporter.emit([event])).then(async () => {
@@ -434,6 +2987,13 @@ var prepareWorkflowTelemetry = (args) => {
   }
   return {
     ...args.config,
+    prepareChildTelemetry: (workflow, config) => prepareWorkflowTelemetry({
+      config,
+      workflow,
+      runId: args.runId,
+      sessionId: args.sessionId,
+      knownWorkflowIds: args.knownWorkflowIds
+    }),
     telemetry: {
       ...telemetry,
       correlation: {
@@ -448,6 +3008,59 @@ var prepareWorkflowTelemetry = (args) => {
   };
 };
 
+// src/telemetry/workflow-call-branch.ts
+var import_node_crypto3 = require("crypto");
+var import_hooks = __toESM(require_dist());
+function restoreWorkflowCallBranch(requests, telemetry, sourceRunId) {
+  const branchId = (0, import_node_crypto3.randomUUID)();
+  const emitted = /* @__PURE__ */ new Set();
+  for (const request of requests) {
+    if (request.state)
+      request.state.config = {
+        ...request.state.config,
+        executionBranchId: branchId
+      };
+    const seen = /* @__PURE__ */ new Set();
+    const visit = (value) => {
+      if (!value || typeof value !== "object" || seen.has(value)) return;
+      seen.add(value);
+      const record = value;
+      if (typeof record.invocationId === "string" && typeof record.fingerprint === "string" && Array.isArray(record.interrupts)) {
+        const previous = record.telemetry;
+        if (previous) {
+          record.sequence = 0;
+          record.telemetry = { ...previous, branchId };
+          if (!emitted.has(record.invocationId)) {
+            emitted.add(record.invocationId);
+            (0, import_hooks.emitWorkflowCall)(
+              telemetry ? {
+                ...telemetry,
+                correlation: {
+                  runId: request.runId,
+                  workflowId: request.workflow,
+                  ...request.sessionId ? { sessionId: request.sessionId } : {}
+                }
+              } : void 0,
+              "workflow.call.restored",
+              {
+                ...previous,
+                branchId,
+                sourceBranchId: previous.branchId,
+                sourceRunId,
+                sequence: 0,
+                status: record.status
+              }
+            );
+          }
+        }
+      }
+      for (const child of Object.values(record)) visit(child);
+    };
+    visit(request);
+  }
+  return branchId;
+}
+
 // src/chat/process-chat.ts
 var import_runtime3 = require("@kortyx/runtime");
 
@@ -634,6 +3247,21 @@ async function orchestrateGraphStream({
   let pendingRecordToken = null;
   let wroteHumanInput = false;
   const pendingStore = frameworkAdapter?.pendingRequests;
+  const sealPendingSnapshots = async () => {
+    if (typeof frameworkAdapter?.checkpointer?.getTuple !== "function") return;
+    for (const [token, request] of activePendingRequests) {
+      const graphSnapshot = await (0, import_runtime.captureGraphSnapshot)(
+        frameworkAdapter.checkpointer,
+        runId,
+        request.graphCheckpointId
+      );
+      if (graphSnapshot) {
+        const sealed = { ...request, graphSnapshot };
+        activePendingRequests.set(token, sealed);
+        await pendingStore?.update(token, { graphSnapshot });
+      }
+    }
+  };
   const pendingTtlMs = frameworkAdapter?.ttlMs ?? 15 * 60 * 1e3;
   const persistAndEmitInterrupt = async (payload) => {
     if (wroteHumanInput) return;
@@ -719,6 +3347,9 @@ async function orchestrateGraphStream({
       type: "interrupt.created",
       correlation: { nodeId: record.node },
       payload: {
+        workflowCall: record.schema.meta?.workflowCall ?? null,
+        workflowCallPath: record.schema.meta?.workflowCallPath ?? null,
+        branchId: config.executionBranchId ?? runId,
         interruptId: record.requestId,
         requestId: record.requestId,
         kind: record.schema.kind,
@@ -934,6 +3565,7 @@ async function orchestrateGraphStream({
       let workflowDoneData;
       currentGraph.config = currentGraph.config || {};
       currentGraph.config.emit = forwardEmit;
+      currentGraph.config.executionRunId = runId;
       const threadId = currentGraph.config?.session?.id || sessionId || "anonymous-session";
       const checkpointNs = "";
       namespacesUsed.add(checkpointNs);
@@ -1128,6 +3760,7 @@ async function orchestrateGraphStream({
         });
         runTraceSpan.end?.(runTraceEndArgs());
         const resolvedSessionId2 = config?.session?.id || sessionId || "";
+        await sealPendingSnapshots();
         if (resolvedSessionId2 && frameworkAdapter?.sessionCheckpoints) {
           try {
             const checkpoint = await frameworkAdapter.sessionCheckpoints.append(
@@ -1189,6 +3822,7 @@ async function orchestrateGraphStream({
         }
       }
       const resolvedSessionId = config?.session?.id || sessionId || "";
+      await sealPendingSnapshots();
       if (resolvedSessionId && frameworkAdapter?.sessionCheckpoints) {
         try {
           const checkpoint = await frameworkAdapter.sessionCheckpoints.append({
@@ -1305,11 +3939,14 @@ async function tryPrepareResumeStream({
   if (!store) return null;
   const pending = await store.get(meta.token);
   if (!pending || pending.requestId !== meta.requestId) {
-    console.log(
-      `[resume] pending not found or mismatched. token=${meta.token} requestId=${meta.requestId}`
+    throw new Error(
+      "Interrupt is expired, already consumed, or does not match the request."
     );
-    return null;
   }
+  if (pending.sessionId && pending.sessionId !== sessionId)
+    throw new Error("Interrupt belongs to another session.");
+  if (store.take && !await store.take(meta.token))
+    throw new Error("Interrupt has already been resumed or cancelled.");
   if (meta.cancel) {
     await store.delete(pending.token);
     emitTelemetryEvent({
@@ -1327,7 +3964,9 @@ async function tryPrepareResumeStream({
       },
       flush: true
     });
-    return null;
+    return (async function* () {
+      yield { type: "done" };
+    })();
   }
   console.log(
     `[resume] token=${meta.token} requestId=${meta.requestId} selected=${JSON.stringify(
@@ -1357,14 +3996,28 @@ async function tryPrepareResumeStream({
   };
   const wf = await selectWorkflow(resumedState.currentWorkflow);
   const telemetryConfig = prepareWorkflowTelemetry({
-    config,
+    config: {
+      ...config,
+      ...pending.state?.config?.executionBranchId ? { executionBranchId: pending.state.config.executionBranchId } : {}
+    },
     workflow: wf,
     runId: pending.runId,
     sessionId,
     knownWorkflowIds
   });
   resumedState.config = telemetryConfig;
-  const resumeUpdate = {};
+  const resumeUpdate = pending.graphSnapshot ? {
+    config: {
+      ...telemetryConfig,
+      context: pending.state?.config?.context ?? telemetryConfig.context
+    }
+  } : {};
+  if (pending.graphSnapshot && frameworkAdapter)
+    await (0, import_runtime2.restoreGraphSnapshot)(
+      frameworkAdapter.checkpointer,
+      pending.graphSnapshot,
+      pending.runId
+    );
   if (Object.keys(resumeDataPatch).length > 0) {
     resumeUpdate.data = {
       ...pendingData,
@@ -1468,6 +4121,7 @@ async function streamChat({
       "streamChat requires selectWorkflow or workflowRegistry to resolve workflows."
     );
   }
+  runtimeConfig.selectWorkflow = workflowSelector;
   const fallbackSessionId = options?.sessionId;
   const resolvedSessionId = sessionId || fallbackSessionId || "anonymous-session";
   const last = messages[messages.length - 1];
@@ -1617,7 +4271,7 @@ var hydratePendingGraphCheckpoint = async (frameworkAdapter, request) => {
   return graphCheckpointId ? { ...request, graphCheckpointId } : request;
 };
 var clearPendingGraphWrites = async (frameworkAdapter, request) => {
-  if (!request.graphCheckpointId) return;
+  if (request.graphSnapshot || !request.graphCheckpointId) return;
   const checkpointer = frameworkAdapter.checkpointer;
   if (!checkpointer?.deleteCheckpointWrites) return;
   await Promise.all([
@@ -1726,6 +4380,11 @@ function createAgent(args) {
         (request) => hydratePendingGraphCheckpoint(resolvedFrameworkAdapter, request)
       )
     );
+    restoreWorkflowCallBranch(
+      activePendingRequests,
+      telemetry,
+      target?.runId ?? "unknown"
+    );
     await Promise.all(
       activePendingRequests.map(
         (request) => clearPendingGraphWrites(resolvedFrameworkAdapter, request)
@@ -1757,6 +4416,7 @@ function createAgent(args) {
     return { ...result, activePendingRequests };
   };
   const fork = async (id, options) => {
+    const source = await resolvedFrameworkAdapter.sessionCheckpoints.get(id);
     const result = await resolvedFrameworkAdapter.sessionCheckpoints.fork(
       id,
       options
@@ -1766,6 +4426,11 @@ function createAgent(args) {
         (request) => hydratePendingGraphCheckpoint(resolvedFrameworkAdapter, request)
       )
     );
+    restoreWorkflowCallBranch(
+      activePendingRequests,
+      telemetry,
+      source?.runId ?? "unknown"
+    );
     await Promise.all(
       activePendingRequests.map(
         (request) => clearPendingGraphWrites(resolvedFrameworkAdapter, request)