@kortyx/agent 0.15.0 → 0.18.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,13 +17,2628 @@ 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,
+      useAbortSignal: () => useAbortSignal,
+      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 import_core5 = require("@kortyx/core");
+    var resolveReasonCheckpointKey = (args) => typeof args.id === "string" && args.id.length > 0 ? `__useReason:${args.id}` : `__useReason:auto:${args.autoIndex}`;
+    var readReasonCheckpoint = (raw) => {
+      if (!raw || typeof raw !== "object") return void 0;
+      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();
+      (0, import_core5.throwIfExecutionAborted)(ctx.node.abortSignal);
+      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_core52 = require("@kortyx/core");
+    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_core32 = require("@kortyx/core");
+    var import_node_crypto22 = require("crypto");
+    var import_core22 = require("@kortyx/core");
+    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;
+      (0, import_core22.throwIfExecutionAborted)(abortSignal);
+      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) {
+            (0, import_core22.throwIfExecutionAborted)(abortSignal);
+            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 } : {}
+          };
+          (0, import_core22.throwIfExecutionAborted)(abortSignal);
+          endTrace(traceSpan, result2);
+          return result2;
+        }
+        const response = await model.invoke(messages);
+        (0, import_core22.throwIfExecutionAborted)(abortSignal);
+        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) {
+        const failure = abortSignal?.aborted ? (0, import_core22.createExecutionCancelledError)() : error;
+        failTrace(traceSpan, failure);
+        throw failure;
+      }
+    }
+    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();
+      const abortSignal = (0, import_core32.combineAbortSignals)(
+        ctx.node.abortSignal,
+        args.abortSignal,
+        args.model.options?.abortSignal
+      );
+      (0, import_core32.throwIfExecutionAborted)(abortSignal);
+      ctx.node.consumeExecution?.("maxModelPasses");
+      return runReasonEngine({
+        model: args.model,
+        input: inputOverride ?? args.input,
+        system: args.system,
+        temperature: args.temperature,
+        maxOutputTokens: args.maxOutputTokens,
+        stopSequences: args.stopSequences,
+        abortSignal,
+        reasoning: args.reasoning,
+        responseFormat: args.responseFormat,
+        providerOptions: args.providerOptions,
+        tools: args.tools,
+        messages: args.messages,
+        defaultTemperature: ctx.node.config?.model?.temperature,
+        stream: args.stream,
+        emit: args.emit,
+        onTextChunk: args.onTextChunk,
+        telemetry: args.telemetry,
+        nodeId: ctx.node.graph.node,
+        emitEvent: ctx.node.emit,
+        reasonTrace: ctx.reasonTrace,
+        id: meta.id,
+        opId: meta.opId
+      });
+    }
+    var tryJsonParse = (value) => {
+      try {
+        return { ok: true, value: JSON.parse(value) };
+      } 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_zod5 = require("zod");
+    var tryStringify2 = (value) => {
+      if (typeof value === "string") return value;
+      try {
+        return JSON.stringify(value, null, 2);
+      } catch {
+        return String(value);
+      }
+    };
+    var tryGetSchemaHint = (schema) => {
+      try {
+        const hint = (0, import_zod5.toJSONSchema)(schema);
+        return JSON.stringify(hint, null, 2);
+      } catch {
+        return void 0;
+      }
+    };
+    var withSchemaHint = (input, label, schema) => {
+      const hint = tryGetSchemaHint(schema);
+      if (!hint) return input;
+      return `${input}
+
+${label}:
+${hint}`;
+    };
+    var defaultInterruptFirstPassInput = (args) => {
+      const mode = args.mode ?? "required";
+      const base = mode === "optional" ? args.outputSchema ? [
+        args.input,
+        "Output rules:",
+        "- Return JSON only. No markdown fences.",
+        "- Return an object with keys: decision, output, interruptRequest, draftText.",
+        '- decision must be either "continue" or "interrupt".',
+        '- Use decision "continue" when you can produce the final output without asking the user.',
+        '- Use decision "interrupt" only when user input is needed before finalizing.',
+        "- output must match the expected output JSON schema.",
+        '- When decision is "interrupt", interruptRequest must match the expected interrupt request JSON schema and must be a non-null object.',
+        '- When decision is "continue", interruptRequest must be null.',
+        "- draftText should be a concise plain-language summary of output."
+      ].join("\n\n") : [
+        args.input,
+        "Output rules:",
+        "- Return JSON only. No markdown fences.",
+        "- Return an object with keys: decision, draftText, interruptRequest.",
+        '- decision must be either "continue" or "interrupt".',
+        '- Use decision "continue" when you can produce the final answer without asking the user.',
+        '- Use decision "interrupt" only when user input is needed before finalizing.',
+        "- draftText should be the current answer text.",
+        '- When decision is "interrupt", interruptRequest must match the expected interrupt request JSON schema and must be a non-null object.',
+        '- When decision is "continue", interruptRequest must be null.'
+      ].join("\n\n") : args.outputSchema ? [
+        args.input,
+        "Output rules:",
+        "- Return JSON only. No markdown fences.",
+        "- Return an object with keys: output, interruptRequest, draftText.",
+        "- output must match the expected output JSON schema.",
+        "- interruptRequest must match the expected interrupt request JSON schema.",
+        "- interruptRequest must be a non-null object.",
+        "- draftText should be a concise plain-language summary of output.",
+        "- If uncertain, still return a valid interruptRequest with safe default options."
+      ].join("\n\n") : [
+        args.input,
+        "Output rules:",
+        "- Return JSON only. No markdown fences.",
+        "- Return an object with keys: draftText, interruptRequest.",
+        "- draftText should be the current draft answer text.",
+        "- interruptRequest must match the expected interrupt request JSON schema.",
+        "- interruptRequest must be a non-null object.",
+        "- If uncertain, still return a valid interruptRequest with safe default options."
+      ].join("\n\n");
+      const withInterruptSchema = withSchemaHint(
+        base,
+        "Expected interrupt request JSON schema (for `interruptRequest`)",
+        args.requestSchema
+      );
+      if (!args.outputSchema) return withInterruptSchema;
+      const withOutputSchema = withSchemaHint(
+        withInterruptSchema,
+        "Expected output JSON schema (for `output`)",
+        args.outputSchema
+      );
+      return [
+        withOutputSchema,
+        "JSON template:",
+        mode === "optional" ? '{ "decision": "continue", "output": { ... }, "interruptRequest": null, "draftText": "..." }' : '{ "output": { ... }, "interruptRequest": { ... }, "draftText": "..." }'
+      ].join("\n\n");
+    };
+    var defaultContinuationInput = (args) => [
+      "You are continuing a paused reasoning task after user input.",
+      "Update the previous result using the user response and return the final answer only.",
+      "If the previous output was JSON, return JSON in the same schema.",
+      "",
+      `Original request:
+${args.input}`,
+      `Draft answer text:
+${args.draftText}`,
+      `Draft output object:
+${tryStringify2(args.draftOutput ?? args.draftText)}`,
+      `Interrupt request shown to user:
+${tryStringify2(args.request)}`,
+      `User response:
+${tryStringify2(args.response)}`
+    ].join("\n\n");
+    var withOutputGuardrails = (input, schema) => {
+      const base = [
+        input,
+        "Output rules:",
+        "- Return only JSON, no markdown fences.",
+        "- Ensure the response conforms to the expected output schema.",
+        "- Do not include explanatory text outside the JSON object."
+      ].join("\n\n");
+      return withSchemaHint(base, "Expected output JSON schema", schema);
+    };
+    var withStructuredStreamHints = (input, args) => {
+      const rules = [];
+      for (const path of args.setFieldPaths ?? []) {
+        rules.push(
+          `- For the field path pattern \`${path}\`, write one stable final value and do not rewrite it after it is complete.`
+        );
+      }
+      for (const path of args.appendFieldPaths ?? []) {
+        rules.push(
+          `- For the array field path pattern \`${path}\`, write items in final order and finish each item before starting the next.`
+        );
+        rules.push(
+          `- Once an item in \`${path}\` is complete, do not rewrite or reorder earlier items.`
+        );
+      }
+      for (const path of args.textDeltaFieldPaths ?? []) {
+        rules.push(
+          `- For the string field path pattern \`${path}\`, write the value progressively by appending text to the end.`
+        );
+        rules.push(
+          `- Do not rewrite or replace the earlier prefix of \`${path}\` once emitted.`
+        );
+      }
+      if (rules.length === 0) return input;
+      return [
+        input,
+        "Streaming rules:",
+        ...rules,
+        "- Keep the overall response as valid JSON."
+      ].join("\n\n");
+    };
+    var mergeUsage = (left, right) => {
+      if (!left) return right;
+      if (!right) return left;
+      const sum = (a, b) => a === void 0 && b === void 0 ? void 0 : (a ?? 0) + (b ?? 0);
+      const raw = left.raw || right.raw ? {
+        ...left.raw ?? {},
+        ...right.raw ?? {}
+      } : void 0;
+      const input = sum(left.input, right.input);
+      const output = sum(left.output, right.output);
+      const total = sum(left.total, right.total);
+      const reasoning = sum(left.reasoning, right.reasoning);
+      const cacheRead = sum(left.cacheRead, right.cacheRead);
+      const cacheWrite = sum(left.cacheWrite, right.cacheWrite);
+      const merged = {};
+      if (input !== void 0) merged.input = input;
+      if (output !== void 0) merged.output = output;
+      if (total !== void 0) merged.total = total;
+      if (reasoning !== void 0) merged.reasoning = reasoning;
+      if (cacheRead !== void 0) merged.cacheRead = cacheRead;
+      if (cacheWrite !== void 0) merged.cacheWrite = cacheWrite;
+      if (raw) merged.raw = raw;
+      return merged;
+    };
+    var mergeWarnings = (left, right) => {
+      if (!left?.length) return right;
+      if (!right?.length) return left;
+      const seen = /* @__PURE__ */ new Set();
+      const merged = [];
+      for (const warning of [...left, ...right]) {
+        const key = JSON.stringify(warning);
+        if (seen.has(key)) continue;
+        seen.add(key);
+        merged.push(warning);
+      }
+      return merged;
+    };
+    var mergeProviderMetadata = (left, right) => {
+      if (!left) return right;
+      if (!right) return left;
+      return {
+        ...left,
+        ...right
+      };
+    };
+    var emitReasonStructuredOutput = (args) => {
+      if (!args.emit || !shouldEmitStructured(args.structured)) return;
+      emitStructuredData({
+        dataType: args.structured?.dataType ?? "reason-output",
+        data: args.output,
+        kind: "final",
+        ...args.structured?.schemaId ? { schemaId: args.structured.schemaId } : {},
+        ...args.structured?.schemaVersion ? { schemaVersion: args.structured.schemaVersion } : {},
+        ...args.id ? { id: args.id } : {},
+        streamId: args.opId
+      });
+    };
+    var resolveAppendFieldPaths = (cfg) => {
+      const fields = cfg?.fields;
+      if (!fields) return [];
+      const appendPaths = Object.entries(fields).filter(([, mode]) => mode === "append").map(([path]) => path);
+      for (const path of appendPaths) {
+        assertStructuredPath(path, "useReason structured append");
+      }
+      return appendPaths;
+    };
+    var resolveSetFieldPaths = (cfg) => {
+      const fields = cfg?.fields;
+      if (!fields) return [];
+      const setPaths = Object.entries(fields).filter(([, mode]) => mode === "set").map(([path]) => path);
+      for (const path of setPaths) {
+        assertStructuredPath(path, "useReason structured set");
+      }
+      return setPaths;
+    };
+    var resolveTextDeltaFieldPaths = (cfg) => {
+      const fields = cfg?.fields;
+      if (!fields) return [];
+      const textPaths = Object.entries(fields).filter(([, mode]) => mode === "text-delta").map(([path]) => path);
+      for (const path of textPaths) {
+        assertStructuredPath(path, "useReason structured text-delta");
+      }
+      return textPaths;
+    };
+    var extractCompletedStringValueAt = (args) => {
+      let value = "";
+      for (let i = args.start; i < args.text.length; i += 1) {
+        const ch = args.text[i];
+        if (ch === void 0) break;
+        if (ch === '"') {
+          return {
+            complete: true,
+            value
+          };
+        }
+        if (ch !== "\\") {
+          value += ch;
+          continue;
+        }
+        const next = args.text[i + 1];
+        if (!next) {
+          return {
+            complete: false
+          };
+        }
+        if (next === '"' || next === "\\" || next === "/" || next === "b" || next === "f" || next === "n" || next === "r" || next === "t") {
+          value += next === "b" ? "\b" : next === "f" ? "\f" : next === "n" ? "\n" : next === "r" ? "\r" : next === "t" ? "	" : next;
+          i += 1;
+          continue;
+        }
+        if (next === "u") {
+          const hex = args.text.slice(i + 2, i + 6);
+          if (!/^[0-9a-fA-F]{4}$/.test(hex)) {
+            return {
+              complete: false
+            };
+          }
+          value += String.fromCharCode(Number.parseInt(hex, 16));
+          i += 5;
+          continue;
+        }
+        return {
+          complete: false
+        };
+      }
+      return {
+        complete: false
+      };
+    };
+    var skipWhitespace = (text, start) => {
+      let i = start;
+      while (i < text.length && /\s/.test(text[i] ?? "")) i += 1;
+      return i;
+    };
+    var 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 import_core42 = require("@kortyx/core");
+    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 abortSignal = (0, import_core42.combineAbortSignals)(
+        ctx.node.abortSignal,
+        useReasonArgs.abortSignal,
+        useReasonArgs.model.options?.abortSignal
+      );
+      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) {
+          (0, import_core42.throwIfExecutionAborted)(abortSignal);
+          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);
+          accumulateTokenUsage(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) {
+            (0, import_core42.throwIfExecutionAborted)(abortSignal);
+            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 {
+              (0, import_core42.throwIfExecutionAborted)(abortSignal);
+              ctx.node.consumeExecution?.("maxToolCalls");
+              const rawResult = await tool.execute(toolCall.input, {
+                toolCallId: toolCall.id,
+                ...abortSignal ? { abortSignal } : {}
+              });
+              (0, import_core42.throwIfExecutionAborted)(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) {
+              (0, import_core42.throwIfExecutionAborted)(abortSignal);
+              if ((0, import_core42.isExecutionLimitReached)(error) || (0, import_core42.isExecutionCancelled)(error))
+                throw 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 abortSignal = (0, import_core52.combineAbortSignals)(
+        ctx.node.abortSignal,
+        args.abortSignal,
+        args.model.options?.abortSignal
+      );
+      (0, import_core52.throwIfExecutionAborted)(abortSignal);
+      args = { ...args, abortSignal };
+      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 useAbortSignal() {
+      return getHookContext().node.abortSignal;
+    }
+    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_core6 = require("@kortyx/core");
+    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();
+      (0, import_core6.throwIfExecutionAborted)(ctx.node.abortSignal);
+      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"
+        );
+      if (!record) ctx.node.consumeExecution?.("maxChildInvocations");
+      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 recordUsage = (usage) => {
+        if (!usage) return;
+        accumulateTokenUsage({
+          input: usage.input - (record.usage?.input ?? 0),
+          output: usage.output - (record.usage?.output ?? 0),
+          total: usage.total - (record.usage?.total ?? 0)
+        });
+        record.usage = usage;
+      };
+      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) {
+            (0, import_core6.throwIfExecutionAborted)(ctx.node.abortSignal);
+            if ((0, import_core6.isExecutionCancelled)(error)) throw error;
+            if ((0, import_core6.isExecutionLimitReached)(error)) {
+              const child = error;
+              if (child.__kortyxChildSnapshot)
+                record.snapshot = child.__kortyxChildSnapshot;
+              recordUsage(child.__kortyxChildUsage);
+              report("suspended", {
+                reason: "limit_reached",
+                limit: error.limitReached
+              });
+              throw 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);
+          }
+          (0, import_core6.throwIfExecutionAborted)(ctx.node.abortSignal);
+          recordUsage(outcome.usage);
+          if (outcome.status === "completed") {
+            record.data = outcome.data;
+            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 = {};
 __export(index_exports, {
+  ExecutionRequestError: () => ExecutionRequestError,
   createAgent: () => createAgent,
   createChatRouteHandler: () => createChatRouteHandler,
   createCheckpointRouteHandler: () => createCheckpointRouteHandler,
@@ -99,6 +2719,7 @@ function parseCheckpointRequestBody(value) {
 async function handleChatRequestBody(args) {
   const { agent, body } = args;
   const stream = await agent.streamChat(body.messages, {
+    ...args.abortSignal ? { abortSignal: args.abortSignal } : {},
     sessionId: body.sessionId,
     workflowId: body.workflowId,
     context: body.context
@@ -118,7 +2739,11 @@ function createChatRouteHandler(args) {
   return async function POST(request) {
     try {
       const body = parseChatRequestBody(await request.json());
-      return await handleChatRequestBody({ agent, body });
+      return await handleChatRequestBody({
+        agent,
+        body,
+        abortSignal: request.signal
+      });
     } catch (error) {
       return new Response(
         JSON.stringify({
@@ -184,10 +2809,168 @@ async function* streamChatFromRoute(args) {
 
 // src/chat/create-agent.ts
 var import_node_path = require("path");
+var import_core4 = require("@kortyx/core");
 var import_providers = require("@kortyx/providers");
-var import_runtime4 = require("@kortyx/runtime");
+var import_runtime5 = require("@kortyx/runtime");
+var import_zod4 = require("zod");
+
+// src/execution/execute.ts
+var import_core3 = require("@kortyx/core");
+var import_runtime3 = require("@kortyx/runtime");
+var import_zod3 = require("zod");
+
+// src/interrupt/resume-handler.ts
+var import_core2 = require("@kortyx/core");
+var import_runtime2 = require("@kortyx/runtime");
+
+// src/orchestrator.ts
+var import_node_stream = require("stream");
+var import_core = require("@kortyx/core");
+var import_runtime = require("@kortyx/runtime");
+var import_langgraph = require("@langchain/langgraph");
+
+// src/execution/contracts.ts
 var import_zod2 = require("zod");
 
+// src/execution/types.ts
+var ExecutionRequestError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+  code;
+  name = "ExecutionRequestError";
+};
+
+// src/execution/contracts.ts
+async function resolveExecutionWorkflow(select, reference) {
+  const id = typeof reference === "string" ? reference : reference.id;
+  let workflow;
+  try {
+    workflow = await select(id);
+  } catch {
+    throw new ExecutionRequestError(
+      "UNKNOWN_WORKFLOW",
+      `Workflow '${id}' is not registered.`
+    );
+  }
+  if (workflow.id !== id)
+    throw new ExecutionRequestError(
+      "UNKNOWN_WORKFLOW",
+      `Workflow '${id}' is not registered.`
+    );
+  if (!workflow.inputSchema || !workflow.outputSchema)
+    throw new ExecutionRequestError(
+      "MISSING_CONTRACT",
+      `Workflow '${id}' requires inputSchema and outputSchema.`
+    );
+  if (typeof reference !== "string" && (reference.version !== workflow.version || reference.inputSchema !== workflow.inputSchema || reference.outputSchema !== workflow.outputSchema))
+    throw new ExecutionRequestError(
+      "CONTRACT_MISMATCH",
+      "The typed workflow contract does not match the registered definition."
+    );
+  return workflow;
+}
+function parseExecutionInput(workflow, input) {
+  try {
+    import_zod2.z.json().parse(input);
+    const parsed = workflow.inputSchema ? workflow.inputSchema.parse(input) : input;
+    import_zod2.z.json().parse(parsed);
+    return parsed;
+  } catch (error) {
+    throw new ExecutionRequestError(
+      "INVALID_INPUT",
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+async function validateExecutionOutput(state, select) {
+  if (!state.config?.executionContract) return state;
+  const terminal = await select(String(state.currentWorkflow));
+  const contract = state.config.executionContract;
+  const root = await select(contract.id);
+  if (root.id !== contract.id || root.version !== contract.version)
+    throw new Error("The root workflow changed since execution started.");
+  let data = state.data ?? {};
+  try {
+    for (const schema of /* @__PURE__ */ new Set([terminal.outputSchema, root.outputSchema])) {
+      if (schema) data = schema.parse(data);
+    }
+    if (terminal.outputSchema || root.outputSchema) import_zod2.z.json().parse(data);
+  } catch (error) {
+    const failure = new Error(
+      `Workflow output validation failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+    Object.assign(failure, { code: "INVALID_OUTPUT" });
+    throw failure;
+  }
+  return { ...state, data };
+}
+
+// src/stream/transform-graph-stream-for-ui.ts
+var isGraphStateOutput = (value) => value !== null && typeof value === "object" && !Array.isArray(value) && "currentWorkflow" in value;
+async function* transformGraphStreamForUI(stream, options = {}) {
+  const { debug = false, emitStatus = debug } = options;
+  const startedNodes = /* @__PURE__ */ new Set();
+  const endedNodes = /* @__PURE__ */ new Set();
+  let latestGraphState = null;
+  for await (const event of stream) {
+    const { event: type, name, data } = event ?? {};
+    if (debug) console.log(`[debug:event]`, JSON.stringify(event, null, 2));
+    switch (type) {
+      case "on_chain_start":
+        if (name && !name.startsWith("ChannelWrite")) {
+          if (name === "__start__" || name === "__end__") break;
+          if (startedNodes.has(name)) break;
+          startedNodes.add(name);
+          if (debug) console.log(`[debug:start] node=${name}`);
+          if (emitStatus) {
+            yield { type: "status", message: `Processing node: ${name}` };
+          }
+        }
+        break;
+      case "on_chain_end": {
+        const nodeName = name;
+        const output = data?.output;
+        if (debug)
+          console.log(
+            `[debug:on_chain_end:${nodeName}] output=`,
+            JSON.stringify(output, null, 2)
+          );
+        if (!output || nodeName?.startsWith("ChannelWrite")) break;
+        if (isGraphStateOutput(output)) latestGraphState = output;
+        if (nodeName !== "__start__" && nodeName !== "__end__") {
+          if (!endedNodes.has(nodeName)) {
+            if (emitStatus) {
+              yield {
+                type: "status",
+                message: `\u2705 Completed node: ${nodeName}`
+              };
+            }
+            endedNodes.add(nodeName);
+          }
+        }
+        break;
+      }
+      case "on_graph_end": {
+        if (debug)
+          console.log(`[debug:on_graph_end]`, JSON.stringify(data, null, 2));
+        const output = data?.output;
+        yield {
+          type: "done",
+          data: isGraphStateOutput(output) ? output : latestGraphState
+        };
+        break;
+      }
+      default:
+        if (debug) {
+          console.warn(`[debug:unknown_event]`, type);
+        }
+        break;
+    }
+  }
+}
+
 // src/telemetry/events.ts
 var import_node_crypto = require("crypto");
 var isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
@@ -237,7 +3020,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 () => {
@@ -392,136 +3178,68 @@ var projectWorkflowTopology = (args) => {
     environment: args.environment,
     service: args.service,
     workflow: {
-      id: args.workflow.id,
-      declaredVersion: args.workflow.version,
-      ...args.workflow.description ? { description: args.workflow.description } : {},
-      ...tags ? { tags } : {},
-      topologyHash,
-      nodes: nodes.map(({ _execution: _ignored, ...node }) => node),
-      edges,
-      ...transitions.length > 0 ? { transitions } : {}
-    }
-  };
-};
-var prepareWorkflowTelemetry = (args) => {
-  const telemetry = isRecord2(args.config.telemetry) ? args.config.telemetry : void 0;
-  if (!telemetry?.reporter || !telemetry.environment || !telemetry.service) {
-    return args.config;
-  }
-  let snapshot;
-  try {
-    snapshot = projectWorkflowTopology({
-      workflow: args.workflow,
-      environment: telemetry.environment,
-      service: telemetry.service,
-      knownWorkflowIds: args.knownWorkflowIds
-    });
-  } catch {
-    return args.config;
-  }
-  let workflowRevisionId;
-  try {
-    workflowRevisionId = telemetry.reporter.getWorkflowRevisionId?.({
-      environment: snapshot.environment,
-      workflowId: snapshot.workflow.id,
-      topologyHash: snapshot.workflow.topologyHash
-    });
-    void Promise.resolve(
-      telemetry.reporter.ensureWorkflowTopology(snapshot)
-    ).catch(() => {
-    });
-  } catch {
-  }
-  return {
-    ...args.config,
-    telemetry: {
-      ...telemetry,
-      correlation: {
-        ...telemetry.correlation ?? {},
-        runId: args.runId,
-        ...args.sessionId ? { sessionId: args.sessionId } : {},
-        workflowId: snapshot.workflow.id,
-        topologyHash: snapshot.workflow.topologyHash,
-        ...workflowRevisionId ? { workflowRevisionId } : {}
-      }
-    }
-  };
-};
-
-// src/chat/process-chat.ts
-var import_runtime3 = require("@kortyx/runtime");
-
-// src/interrupt/resume-handler.ts
-var import_runtime2 = require("@kortyx/runtime");
-
-// src/orchestrator.ts
-var import_node_stream = require("stream");
-var import_runtime = require("@kortyx/runtime");
-var import_langgraph = require("@langchain/langgraph");
-
-// src/stream/transform-graph-stream-for-ui.ts
-var isGraphStateOutput = (value) => value !== null && typeof value === "object" && !Array.isArray(value) && "currentWorkflow" in value;
-async function* transformGraphStreamForUI(stream, options = {}) {
-  const { debug = false, emitStatus = debug } = options;
-  const startedNodes = /* @__PURE__ */ new Set();
-  const endedNodes = /* @__PURE__ */ new Set();
-  let latestGraphState = null;
-  for await (const event of stream) {
-    const { event: type, name, data } = event ?? {};
-    if (debug) console.log(`[debug:event]`, JSON.stringify(event, null, 2));
-    switch (type) {
-      case "on_chain_start":
-        if (name && !name.startsWith("ChannelWrite")) {
-          if (name === "__start__" || name === "__end__") break;
-          if (startedNodes.has(name)) break;
-          startedNodes.add(name);
-          if (debug) console.log(`[debug:start] node=${name}`);
-          if (emitStatus) {
-            yield { type: "status", message: `Processing node: ${name}` };
-          }
-        }
-        break;
-      case "on_chain_end": {
-        const nodeName = name;
-        const output = data?.output;
-        if (debug)
-          console.log(
-            `[debug:on_chain_end:${nodeName}] output=`,
-            JSON.stringify(output, null, 2)
-          );
-        if (!output || nodeName?.startsWith("ChannelWrite")) break;
-        if (isGraphStateOutput(output)) latestGraphState = output;
-        if (nodeName !== "__start__" && nodeName !== "__end__") {
-          if (!endedNodes.has(nodeName)) {
-            if (emitStatus) {
-              yield {
-                type: "status",
-                message: `\u2705 Completed node: ${nodeName}`
-              };
-            }
-            endedNodes.add(nodeName);
-          }
-        }
-        break;
-      }
-      case "on_graph_end": {
-        if (debug)
-          console.log(`[debug:on_graph_end]`, JSON.stringify(data, null, 2));
-        const output = data?.output;
-        yield {
-          type: "done",
-          data: isGraphStateOutput(output) ? output : latestGraphState
-        };
-        break;
-      }
-      default:
-        if (debug) {
-          console.warn(`[debug:unknown_event]`, type);
-        }
-        break;
+      id: args.workflow.id,
+      declaredVersion: args.workflow.version,
+      ...args.workflow.description ? { description: args.workflow.description } : {},
+      ...tags ? { tags } : {},
+      topologyHash,
+      nodes: nodes.map(({ _execution: _ignored, ...node }) => node),
+      edges,
+      ...transitions.length > 0 ? { transitions } : {}
     }
+  };
+};
+var prepareWorkflowTelemetry = (args) => {
+  const telemetry = isRecord2(args.config.telemetry) ? args.config.telemetry : void 0;
+  if (!telemetry?.reporter || !telemetry.environment || !telemetry.service) {
+    return args.config;
   }
-}
+  let snapshot;
+  try {
+    snapshot = projectWorkflowTopology({
+      workflow: args.workflow,
+      environment: telemetry.environment,
+      service: telemetry.service,
+      knownWorkflowIds: args.knownWorkflowIds
+    });
+  } catch {
+    return args.config;
+  }
+  let workflowRevisionId;
+  try {
+    workflowRevisionId = telemetry.reporter.getWorkflowRevisionId?.({
+      environment: snapshot.environment,
+      workflowId: snapshot.workflow.id,
+      topologyHash: snapshot.workflow.topologyHash
+    });
+    void Promise.resolve(
+      telemetry.reporter.ensureWorkflowTopology(snapshot)
+    ).catch(() => {
+    });
+  } catch {
+  }
+  return {
+    ...args.config,
+    prepareChildTelemetry: (workflow, config) => prepareWorkflowTelemetry({
+      config,
+      workflow,
+      runId: args.runId,
+      sessionId: args.sessionId,
+      knownWorkflowIds: args.knownWorkflowIds
+    }),
+    telemetry: {
+      ...telemetry,
+      correlation: {
+        ...telemetry.correlation ?? {},
+        runId: args.runId,
+        ...args.sessionId ? { sessionId: args.sessionId } : {},
+        workflowId: snapshot.workflow.id,
+        topologyHash: snapshot.workflow.topologyHash,
+        ...workflowRevisionId ? { workflowRevisionId } : {}
+      }
+    }
+  };
+};
 
 // src/orchestrator.ts
 var isRecord3 = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
@@ -544,15 +3262,30 @@ async function orchestrateGraphStream({
   graph,
   state,
   config: initialConfig,
+  abortSignal: requestSignal,
+  emitOutput = true,
+  onOutcome,
   selectWorkflow,
   knownWorkflowIds,
   frameworkAdapter
 }) {
   const out = new import_node_stream.PassThrough({ objectMode: true });
+  const write = (chunk) => {
+    if (emitOutput && !out.destroyed) out.write(chunk);
+  };
+  let outcomeState = state;
+  let outcomeError;
+  let sessionCheckpointId;
   let config = initialConfig;
+  const budget = config.executionBudget;
   let currentGraph = graph;
   let currentState = state;
   let finished = false;
+  const controller = new AbortController();
+  const abortSignal = (0, import_core.combineAbortSignals)(requestSignal, controller.signal);
+  out.on("close", () => {
+    if (!finished) controller.abort();
+  });
   let structuredSeq = 0;
   const debugEnabled = Boolean(config?.features?.tracing);
   const traceAdapter = getTraceAdapter(config);
@@ -593,7 +3326,7 @@ async function orchestrateGraphStream({
       },
       tags: Array.isArray(telemetryConfig.tags) ? telemetryConfig.tags : void 0,
       captureContent: telemetryConfig.captureContent,
-      ...typeof state.input === "string" ? { input: state.input } : {}
+      input: typeof state.input === "string" ? state.input : JSON.stringify(state.input)
     }
   };
   const namespacesUsed = /* @__PURE__ */ new Set();
@@ -604,7 +3337,7 @@ async function orchestrateGraphStream({
   try {
     const sid = config?.session?.id;
     if (sid && typeof sid === "string") {
-      out.write({ type: "session", sessionId: sid });
+      write({ type: "session", sessionId: sid });
     }
   } catch {
   }
@@ -628,12 +3361,33 @@ async function orchestrateGraphStream({
     }
     lastOutputSegmentId = textStreamId;
     accumulatedOutput += delta;
+    if (!emitOutput) accumulatedOutput = accumulatedOutput.slice(0, 65536);
   };
   const nextStructuredStreamId = () => `${runId}:structured:${structuredSeq++}`;
   const runTraceEndArgs = () => accumulatedOutput.length > 0 ? { telemetry: { output: accumulatedOutput } } : void 0;
   let pendingRecordToken = null;
   let wroteHumanInput = false;
   const pendingStore = frameworkAdapter?.pendingRequests;
+  const sealPendingSnapshots = async () => {
+    if (budget) outcomeState.config.executionBudget = budget;
+    if (typeof frameworkAdapter?.checkpointer?.getTuple !== "function") return;
+    for (const [token, request] of activePendingRequests) {
+      if (budget) request.state.config.executionBudget = budget;
+      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,
+          state: request.state
+        });
+      }
+    }
+  };
   const pendingTtlMs = frameworkAdapter?.ttlMs ?? 15 * 60 * 1e3;
   const persistAndEmitInterrupt = async (payload) => {
     if (wroteHumanInput) return;
@@ -681,6 +3435,7 @@ async function orchestrateGraphStream({
     activePendingRequests.set(record.token, record);
     if (pendingStore) {
       const savePromise = pendingStore.save(record).catch((error) => {
+        outcomeError = error;
         console.error("[orchestrator] failed to save pending request", error);
       });
       pendingRequestWrites.push(savePromise);
@@ -690,7 +3445,7 @@ async function orchestrateGraphStream({
         ([key]) => !key.startsWith("__kortyx")
       )
     ) : void 0;
-    out.write({
+    write({
       type: "interrupt",
       requestId: record.requestId,
       resumeToken: record.token,
@@ -719,6 +3474,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,
@@ -749,8 +3507,9 @@ async function orchestrateGraphStream({
       const msg = String(
         payload?.message ?? "Unexpected error"
       );
-      out.write({ type: "error", message: msg });
-      out.write({ type: "done" });
+      outcomeError = new Error(msg);
+      write({ type: "error", message: msg });
+      write({ type: "done" });
       finished = true;
       out.end();
       return;
@@ -763,14 +3522,14 @@ async function orchestrateGraphStream({
       if (msg && msg === lastStatusMsg && now - lastStatusAt < 250) return;
       lastStatusMsg = msg;
       lastStatusAt = now;
-      out.write({ type: "status", message: msg });
+      write({ type: "status", message: msg });
       return;
     }
     if (event === "text-start") {
       const node = payload?.node;
       if (!node) return;
       touchedNodes.add(node);
-      out.write({
+      write({
         type: "text-start",
         node,
         ...typeof payload.id === "string" ? { id: payload.id } : {},
@@ -785,7 +3544,7 @@ async function orchestrateGraphStream({
       if (!node || !delta) return;
       touchedNodes.add(node);
       appendAccumulatedOutput(payload, node, delta);
-      out.write({
+      write({
         type: "text-delta",
         delta,
         node,
@@ -799,7 +3558,7 @@ async function orchestrateGraphStream({
       const node = payload?.node;
       if (!node) return;
       touchedNodes.add(node);
-      out.write({
+      write({
         type: "text-end",
         node,
         ...typeof payload.id === "string" ? { id: payload.id } : {},
@@ -813,7 +3572,7 @@ async function orchestrateGraphStream({
       if (typeof payloadObj.tool !== "string" || typeof payloadObj.toolCallId !== "string") {
         return;
       }
-      out.write({
+      write({
         type: "tool-call-start",
         tool: payloadObj.tool,
         toolCallId: payloadObj.toolCallId,
@@ -830,7 +3589,7 @@ async function orchestrateGraphStream({
       if (typeof payloadObj.tool !== "string" || typeof payloadObj.toolCallId !== "string") {
         return;
       }
-      out.write({
+      write({
         type: "tool-call-result",
         tool: payloadObj.tool,
         toolCallId: payloadObj.toolCallId,
@@ -849,7 +3608,7 @@ async function orchestrateGraphStream({
       if (typeof payloadObj.tool !== "string" || typeof payloadObj.toolCallId !== "string") {
         return;
       }
-      out.write({
+      write({
         type: "tool-call-error",
         tool: payloadObj.tool,
         toolCallId: payloadObj.toolCallId,
@@ -865,7 +3624,7 @@ async function orchestrateGraphStream({
       const node = payload?.node;
       const text = String(payload?.content ?? "");
       if (node) touchedNodes.add(node);
-      out.write({ type: "message", node, content: text });
+      write({ type: "message", node, content: text });
       return;
     }
     if (event === "structured_data") {
@@ -874,7 +3633,7 @@ async function orchestrateGraphStream({
       const streamId = typeof payloadObj.streamId === "string" && payloadObj.streamId ? payloadObj.streamId : nextStructuredStreamId();
       structuredStreamIds.add(streamId);
       if (payloadObj.node) touchedNodes.add(payloadObj.node);
-      out.write({
+      write({
         type: "structured-data",
         node: payloadObj.node,
         streamId,
@@ -900,7 +3659,7 @@ async function orchestrateGraphStream({
       return;
     }
     if (event === "transition") {
-      out.write({
+      write({
         type: "transition",
         transitionTo: payload?.transitionTo,
         payload: payload?.payload ?? {}
@@ -928,12 +3687,17 @@ async function orchestrateGraphStream({
   };
   const runLoop = async (runTraceSpan) => {
     while (true) {
+      (0, import_core.throwIfExecutionAborted)(abortSignal);
       let workflowFinalState = null;
       let workflowFinalGraphCheckpointId;
       let sawWorkflowDone = false;
       let workflowDoneData;
+      currentGraph.execution ??= {};
+      currentGraph.execution.abortSignal = abortSignal;
+      currentGraph.execution.budget = budget;
       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);
@@ -963,7 +3727,7 @@ async function orchestrateGraphStream({
         };
       };
       if (debugEnabled) {
-        out.write({
+        write({
           type: "status",
           message: `\u{1F9F5} thread_id=${threadId} run_id=${runId} workflow=${currentState.currentWorkflow}`
         });
@@ -982,16 +3746,32 @@ async function orchestrateGraphStream({
         }
       });
       if (debugEnabled) {
-        out.write({
+        write({
           type: "status",
           message: `\u25B6\uFE0F streamEvents invoke: resume=${Boolean(currentGraph.config?.resume)} thread_id=${threadId} run_id=${runId} ns=${String(currentState.currentWorkflow || "default")}`
         });
       }
-      const uiStream = transformGraphStreamForUI(runtimeStream, {
+      const observedStream = (async function* () {
+        for await (const event of runtimeStream) {
+          const raw = event;
+          if ((raw.event === "on_chain_end" || raw.event === "on_graph_end") && !raw.name?.startsWith("ChannelWrite") && isGraphState(raw.data?.output)) {
+            outcomeState = raw.data.output;
+          }
+          yield event;
+        }
+      })();
+      const uiStream = transformGraphStreamForUI(observedStream, {
         debug: debugEnabled,
         emitStatus: debugEnabled
       });
-      for await (const chunk of uiStream) {
+      if (!emitOutput) {
+        for await (const _event of observedStream) {
+          if (finished) break;
+        }
+        sawWorkflowDone = true;
+        workflowDoneData = outcomeState;
+      }
+      for await (const chunk of emitOutput ? uiStream : []) {
         if (finished) break;
         if ("node" in chunk && typeof chunk.node === "string") {
           touchedNodes.add(chunk.node);
@@ -1001,14 +3781,18 @@ async function orchestrateGraphStream({
           workflowDoneData = chunk.data;
           continue;
         }
-        out.write(chunk);
+        write(chunk);
+      }
+      if (finished) {
+        runTraceSpan.fail?.(outcomeError);
+        return;
       }
-      if (finished) return;
       if (sawWorkflowDone) {
         const graphSnapshot = await readLatestGraphSnapshot();
         workflowFinalGraphCheckpointId = graphSnapshot?.checkpointId;
         workflowFinalState = isGraphState(workflowDoneData) ? workflowDoneData : graphSnapshot?.state ?? currentState;
       }
+      (0, import_core.throwIfExecutionAborted)(abortSignal);
       const transitionTo = pending.to;
       const transitionPayload = pending.payload;
       const sourceNodeId = pending.sourceNodeId;
@@ -1045,6 +3829,10 @@ async function orchestrateGraphStream({
               } : {}
             }
           });
+          delete config.resume;
+          delete config.resumeValue;
+          delete config.resumeUpdate;
+          delete config.resumeCheckpointId;
           const nextGraph = await (0, import_runtime.createExecutionGraph)(nextWorkflow, {
             ...config,
             emit: forwardEmit
@@ -1055,12 +3843,13 @@ async function orchestrateGraphStream({
             ...transitionPayload
           };
           const rawInputFromPayload = transitionPayload?.rawInput;
-          const newInput = typeof rawInputFromPayload === "string" ? rawInputFromPayload : currentState.input;
+          const rawNextInput = typeof rawInputFromPayload === "string" ? rawInputFromPayload : currentState.input;
           currentState = {
             ...currentState,
+            runtime: workflowFinalState?.runtime ?? currentState.runtime,
             currentWorkflow: transitionTo,
             config,
-            input: newInput,
+            input: nextWorkflow.inputSchema ? parseExecutionInput(nextWorkflow, rawNextInput) : rawNextInput,
             data: mergedData,
             ui: {}
             // reset UI layer on new graph
@@ -1068,14 +3857,18 @@ async function orchestrateGraphStream({
           currentGraph = nextGraph;
           continue;
         } catch (err) {
+          (0, import_core.throwIfExecutionAborted)(abortSignal);
+          if ((0, import_core.isExecutionCancelled)(err)) throw err;
+          outcomeError = err;
+          runTraceSpan.fail?.(err);
           runTraceSpan.addEvent?.("kortyx.transition.error", {
             transitionTo
           });
-          out.write({
+          write({
             type: "error",
             message: `Transition failed to '${transitionTo}': ${err instanceof Error ? err.message : String(err)}`
           });
-          out.write({ type: "done" });
+          write({ type: "done" });
           out.end();
           return;
         }
@@ -1105,6 +3898,10 @@ async function orchestrateGraphStream({
         }
         const shouldKeepFrameworkState = Boolean(pendingRecordToken) || Boolean(workflowFinalState?.awaitingHumanInput);
         if (!shouldKeepFrameworkState) {
+          workflowFinalState = await validateExecutionOutput(
+            workflowFinalState,
+            selectWorkflow
+          );
           try {
             if (frameworkAdapter?.cleanupRun) {
               await frameworkAdapter.cleanupRun(
@@ -1121,6 +3918,12 @@ async function orchestrateGraphStream({
             console.error("[orchestrator] framework cleanup failed", e);
           }
         }
+        outcomeState = workflowFinalState;
+        if (!emitOutput && !shouldKeepFrameworkState)
+          accumulatedOutput = JSON.stringify(workflowFinalState.data).slice(
+            0,
+            65536
+          );
         finished = true;
         runTraceSpan.setAttributes?.({
           "kortyx.run.awaiting_human_input": shouldKeepFrameworkState,
@@ -1128,6 +3931,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(
@@ -1142,7 +3946,8 @@ async function orchestrateGraphStream({
                 pendingRequests: Array.from(activePendingRequests.values())
               }
             );
-            out.write({
+            sessionCheckpointId = checkpoint.id;
+            write({
               type: "checkpoint",
               id: checkpoint.id,
               sessionId: checkpoint.sessionId,
@@ -1160,15 +3965,23 @@ async function orchestrateGraphStream({
               }
             });
           } catch (error) {
+            outcomeError = error;
             console.error("[orchestrator] session checkpoint failed", error);
           }
         }
-        out.write({ type: "done", data: workflowFinalState });
+        write({ type: "done", data: workflowFinalState });
         out.end();
         return;
       }
       const naturalGraphSnapshot = await readLatestGraphSnapshot();
-      const naturalFinalState = naturalGraphSnapshot?.state ?? currentState;
+      let naturalFinalState = naturalGraphSnapshot?.state ?? currentState;
+      if (!pendingRecordToken && !naturalFinalState.awaitingHumanInput) {
+        naturalFinalState = await validateExecutionOutput(
+          naturalFinalState,
+          selectWorkflow
+        );
+      }
+      outcomeState = naturalFinalState;
       if (pendingRequestWrites.length > 0) {
         await Promise.all(pendingRequestWrites);
       }
@@ -1189,6 +4002,7 @@ async function orchestrateGraphStream({
         }
       }
       const resolvedSessionId = config?.session?.id || sessionId || "";
+      await sealPendingSnapshots();
       if (resolvedSessionId && frameworkAdapter?.sessionCheckpoints) {
         try {
           const checkpoint = await frameworkAdapter.sessionCheckpoints.append({
@@ -1201,7 +4015,8 @@ async function orchestrateGraphStream({
             structuredStreamIds: Array.from(structuredStreamIds),
             pendingRequests: Array.from(activePendingRequests.values())
           });
-          out.write({
+          sessionCheckpointId = checkpoint.id;
+          write({
             type: "checkpoint",
             id: checkpoint.id,
             sessionId: checkpoint.sessionId,
@@ -1219,14 +4034,16 @@ async function orchestrateGraphStream({
             }
           });
         } catch (error) {
+          outcomeError = error;
           console.error("[orchestrator] session checkpoint failed", error);
         }
       }
       runTraceSpan.setAttributes?.({
         "kortyx.run.final_workflow": String(naturalFinalState.currentWorkflow)
       });
+      finished = true;
       runTraceSpan.end?.(runTraceEndArgs());
-      out.write({ type: "done", data: naturalFinalState });
+      write({ type: "done", data: naturalFinalState });
       out.end();
       return;
     }
@@ -1234,7 +4051,7 @@ async function orchestrateGraphStream({
   const emitTraceChunk = () => {
     const traceContext = traceAdapter?.getActiveContext?.();
     if (!traceContext) return;
-    out.write({
+    write({
       type: "trace",
       traceId: traceContext.traceId,
       spanId: traceContext.spanId,
@@ -1250,16 +4067,165 @@ async function orchestrateGraphStream({
     emitTraceChunk();
     return runLoop(runTraceSpan);
   }) : runLoop(fallbackRunSpan ?? {});
-  runPromise.catch((err) => {
+  const finishCancelled = async () => {
+    emitTelemetryEvent({
+      config,
+      type: "run.cancelled",
+      correlation: { runId, workflowId: outcomeState.currentWorkflow },
+      payload: { reason: "execution_aborted" },
+      flush: true
+    });
+    await Promise.allSettled(pendingRequestWrites);
+    await Promise.allSettled(
+      [...activePendingRequests.keys()].map(
+        (token) => pendingStore?.delete(token)
+      )
+    );
+    activePendingRequests.clear();
+    try {
+      await frameworkAdapter?.cleanupRun?.(runId, [...namespacesUsed]);
+    } catch (cleanupError) {
+      console.error("[cancel:cleanupRun]", cleanupError);
+    }
+    outcomeError = (0, import_core.createExecutionCancelledError)();
+    fallbackRunSpan?.setAttributes?.({ "kortyx.run.cancelled": true });
+    fallbackRunSpan?.end?.();
+    write({ type: "cancelled", runId, reason: "Execution cancelled." });
+    write({ type: "done" });
+    finished = true;
+    out.end();
+  };
+  runPromise.catch(async (err) => {
+    if (abortSignal?.aborted || (0, import_core.isExecutionCancelled)(err)) {
+      await finishCancelled();
+      return;
+    }
+    if ((0, import_core.isExecutionLimitReached)(err)) {
+      try {
+        const snapshot = frameworkAdapter && await (0, import_runtime.captureGraphSnapshot)(frameworkAdapter.checkpointer, runId);
+        (0, import_core.throwIfExecutionAborted)(abortSignal);
+        if (!snapshot)
+          throw new Error(
+            "Execution limit reached without a resumable checkpoint."
+          );
+        const savedState = snapshot.checkpoint.channel_values;
+        const pausedState = {
+          ...savedState,
+          config: {
+            ...savedState.config,
+            ...config,
+            executionBudget: budget
+          },
+          awaitingHumanInput: true
+        };
+        const patch = err.__kortyxHookStatePatch;
+        currentState = pausedState;
+        outcomeState = pausedState;
+        const limitReached = err.limitReached;
+        write({ type: "limit-reached", runId, ...limitReached });
+        emitTelemetryEvent({
+          config,
+          type: "run.limit_reached",
+          payload: limitReached
+        });
+        await persistAndEmitInterrupt({
+          node: String(
+            err.nodeId ?? savedState.lastNode
+          ),
+          workflow: String(savedState.currentWorkflow),
+          input: {
+            kind: "choice",
+            question: "Limit reached \u2014 Continue?",
+            options: [{ id: "continue", label: "Continue" }],
+            meta: {
+              __kortyxExecutionLimit: true,
+              executionLimit: limitReached,
+              ...patch ? { __kortyxResumeStatePatch: patch } : {}
+            }
+          }
+        });
+        await Promise.all(pendingRequestWrites);
+        (0, import_core.throwIfExecutionAborted)(abortSignal);
+        if (outcomeError) throw outcomeError;
+        const request = activePendingRequests.get(pendingRecordToken);
+        const sealed = {
+          ...request,
+          state: pausedState,
+          graphCheckpointId: snapshot.checkpoint.id,
+          graphSnapshot: snapshot
+        };
+        activePendingRequests.set(request.token, sealed);
+        await pendingStore?.update(request.token, sealed);
+        const checkpoint = await frameworkAdapter.sessionCheckpoints.append({
+          sessionId,
+          runId,
+          graphCheckpointId: snapshot.checkpoint.id,
+          workflow: String(pausedState.currentWorkflow),
+          state: pausedState,
+          nodes: Array.from(touchedNodes),
+          structuredStreamIds: Array.from(structuredStreamIds),
+          pendingRequests: [sealed],
+          label: "Execution limit reached"
+        });
+        (0, import_core.throwIfExecutionAborted)(abortSignal);
+        sessionCheckpointId = checkpoint.id;
+        write({
+          type: "checkpoint",
+          id: checkpoint.id,
+          sessionId: checkpoint.sessionId,
+          turnIndex: checkpoint.turnIndex,
+          label: checkpoint.label
+        });
+        emitTelemetryEvent({
+          config,
+          type: "session.checkpointed",
+          payload: {
+            checkpointId: checkpoint.id,
+            turnIndex: checkpoint.turnIndex,
+            nodes: checkpoint.nodes
+          }
+        });
+        fallbackRunSpan?.setAttributes?.({
+          "kortyx.run.awaiting_human_input": true,
+          "kortyx.run.limit_reached": limitReached.limit
+        });
+        fallbackRunSpan?.end?.();
+        finished = true;
+        write({ type: "done" });
+        out.end();
+        return;
+      } catch (pauseError) {
+        if (abortSignal?.aborted || (0, import_core.isExecutionCancelled)(pauseError)) {
+          await finishCancelled();
+          return;
+        }
+        await Promise.allSettled(
+          [...activePendingRequests.keys()].map(
+            (token) => pendingStore?.delete(token)
+          )
+        );
+        activePendingRequests.clear();
+        err = pauseError;
+      }
+    }
+    outcomeError = err;
     fallbackRunSpan?.fail?.(err);
     emitResumeFailure(err);
     console.error("[error:orchestrateGraphStream]", err);
-    out.write({
+    write({
       type: "error",
       message: err instanceof Error ? err.message : String(err)
     });
-    out.write({ type: "done" });
+    write({ type: "done" });
+    finished = true;
     out.end();
+  }).finally(() => {
+    onOutcome?.({
+      state: outcomeState,
+      pending: pendingRecordToken ? activePendingRequests.get(pendingRecordToken) : void 0,
+      checkpointId: sessionCheckpointId,
+      ...outcomeError ? { error: outcomeError } : {}
+    });
   });
   return out;
 }
@@ -1290,7 +4256,13 @@ function parseResumeMeta(msg) {
   return { token, requestId, selected, cancel };
 }
 async function tryPrepareResumeStream({
+  limits,
+  abortSignal,
   lastMessage,
+  meta: suppliedMeta,
+  emitOutput,
+  onOutcome,
+  validatePending,
   sessionId,
   config,
   selectWorkflow,
@@ -1299,17 +4271,38 @@ async function tryPrepareResumeStream({
   applyResumeSelection,
   frameworkAdapter
 }) {
-  const meta = parseResumeMeta(lastMessage);
+  const meta = suppliedMeta ?? parseResumeMeta(lastMessage);
   if (!meta) return null;
   const store = frameworkAdapter?.pendingRequests;
   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.");
+  await validatePending?.(pending);
+  const isLimitPause = Boolean(pending.schema.meta?.__kortyxExecutionLimit);
+  const savedBudget = pending.state?.config?.executionBudget;
+  const resumedBudget = savedBudget && isLimitPause && !meta.cancel ? (0, import_core2.restartExecutionBudget)(savedBudget, limits) : savedBudget;
+  if (abortSignal?.aborted) {
+    onOutcome?.({
+      state: pending.state,
+      error: (0, import_core2.createExecutionCancelledError)()
+    });
+    return (async function* () {
+      yield {
+        type: "cancelled",
+        runId: pending.runId,
+        reason: "Execution cancelled."
+      };
+      yield { type: "done" };
+    })();
+  }
+  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,109 +4320,412 @@ async function tryPrepareResumeStream({
       },
       flush: true
     });
-    return null;
+    onOutcome?.({ state: pending.state, cancelled: true });
+    return (async function* () {
+      yield { type: "done" };
+    })();
   }
-  console.log(
-    `[resume] token=${meta.token} requestId=${meta.requestId} selected=${JSON.stringify(
-      meta.selected
-    )} sessionId=${sessionId}`
-  );
-  const resumeData = applyResumeSelection ? applyResumeSelection({ pending, selected: meta.selected }) : meta.selected?.length ? { coordinates: String(meta.selected[0]) } : {};
-  const resumeDataPatch = isRecord4(resumeData) ? resumeData : {};
-  const pendingMeta = isRecord4(pending.schema?.meta) ? pending.schema.meta : {};
-  const resumeStatePatch = isRecord4(pendingMeta.__kortyxResumeStatePatch) ? pendingMeta.__kortyxResumeStatePatch : void 0;
-  const pendingData = isRecord4(pending.state?.data) ? pending.state?.data : {};
-  const workflowId = typeof pending.workflow === "string" && pending.workflow.trim() ? pending.workflow : typeof defaultWorkflowId === "string" && defaultWorkflowId.trim() ? defaultWorkflowId : "job-search";
-  const resumedState = {
-    // For static breakpoints, resume with null input (set in orchestrator),
-    // and stash the user selection into data so the next node can read it.
-    input: "",
-    lastNode: "__start__",
-    currentWorkflow: workflowId,
-    config,
-    runtime: {},
-    conversationHistory: [],
-    awaitingHumanInput: false,
-    data: {
-      ...pendingData,
-      ...resumeDataPatch
-    }
-  };
-  const wf = await selectWorkflow(resumedState.currentWorkflow);
-  const telemetryConfig = prepareWorkflowTelemetry({
-    config,
-    workflow: wf,
-    runId: pending.runId,
-    sessionId,
-    knownWorkflowIds
-  });
-  resumedState.config = telemetryConfig;
-  const resumeUpdate = {};
-  if (Object.keys(resumeDataPatch).length > 0) {
-    resumeUpdate.data = {
-      ...pendingData,
-      ...resumeDataPatch
+  try {
+    const resumeData = isLimitPause ? {} : applyResumeSelection ? applyResumeSelection({ pending, selected: meta.selected }) : meta.selected?.length ? { coordinates: String(meta.selected[0]) } : {};
+    const resumeDataPatch = isRecord4(resumeData) ? resumeData : {};
+    const pendingMeta = isRecord4(pending.schema?.meta) ? pending.schema.meta : {};
+    const resumeStatePatch = isRecord4(pendingMeta.__kortyxResumeStatePatch) ? pendingMeta.__kortyxResumeStatePatch : void 0;
+    const pendingData = isRecord4(pending.state?.data) ? pending.state?.data : {};
+    const workflowId = typeof pending.workflow === "string" && pending.workflow.trim() ? pending.workflow : typeof defaultWorkflowId === "string" && defaultWorkflowId.trim() ? defaultWorkflowId : "job-search";
+    const resumedState = {
+      // For static breakpoints, resume with null input (set in orchestrator),
+      // and stash the user selection into data so the next node can read it.
+      input: pending.state ? pending.state.input : "",
+      lastNode: "__start__",
+      currentWorkflow: workflowId,
+      config,
+      runtime: {},
+      conversationHistory: [],
+      awaitingHumanInput: false,
+      data: {
+        ...pendingData,
+        ...resumeDataPatch
+      }
     };
-  }
-  if (resumeStatePatch) {
-    resumeUpdate.runtime = resumeStatePatch;
-  }
-  const hasResumeUpdate = Object.keys(resumeUpdate).length > 0;
-  const resumeValue = meta.selected?.length && pending.schema.kind === "multi-choice" ? meta.selected.map((x) => String(x)) : meta.selected?.length ? String(meta.selected[0]) : void 0;
-  const resumeCheckpointId = typeof pending.graphCheckpointId === "string" && pending.graphCheckpointId.length > 0 ? pending.graphCheckpointId : void 0;
-  const resumedGraph = await (0, import_runtime2.createExecutionGraph)(wf, {
-    ...telemetryConfig,
-    resume: true,
-    ...resumeValue !== void 0 ? { resumeValue } : {},
-    ...resumeCheckpointId ? { resumeCheckpointId } : {},
-    ...hasResumeUpdate ? { resumeUpdate } : {}
-  });
-  await store.delete(pending.token);
-  const response = responseFromSelection(meta.selected);
-  const telemetry = isRecord4(telemetryConfig.telemetry) ? telemetryConfig.telemetry : {};
-  const responseCaptured = Boolean(
-    response && shouldCaptureTelemetryContent(telemetry.captureContent, "input")
-  );
-  emitTelemetryEvent({
-    config: telemetryConfig,
-    type: "interrupt.resolved",
-    correlation: {
+    const wf = await selectWorkflow(resumedState.currentWorkflow);
+    const telemetryConfig = prepareWorkflowTelemetry({
+      config: {
+        ...config,
+        ...resumedBudget ? { executionBudget: resumedBudget } : {},
+        ...pending.state?.config?.context ? { context: pending.state.config.context } : {},
+        ...pending.state?.config?.executionContract ? { executionContract: pending.state.config.executionContract } : {},
+        ...pending.state?.config?.executionBranchId ? { executionBranchId: pending.state.config.executionBranchId } : {}
+      },
+      workflow: wf,
       runId: pending.runId,
       sessionId,
-      workflowId,
-      nodeId: pending.node
-    },
-    payload: {
-      interruptId: pending.requestId,
-      resolvedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      resumeOutcome: "resumed",
-      responseCaptured,
-      ...responseCaptured && response ? { response } : {}
-    },
-    flush: true
-  });
-  const args = {
-    sessionId,
-    runId: pending.runId,
-    graph: resumedGraph,
-    state: resumedState,
-    config: {
+      knownWorkflowIds
+    });
+    resumedState.config = telemetryConfig;
+    const resumeUpdate = pending.graphSnapshot ? {
+      config: {
+        ...telemetryConfig,
+        context: pending.state?.config?.context ?? telemetryConfig.context
+      }
+    } : {};
+    if (isLimitPause && pending.graphSnapshot) {
+      pending.graphSnapshot.checkpoint.channel_values.config = telemetryConfig;
+      if (resumeStatePatch)
+        pending.graphSnapshot.checkpoint.channel_values.runtime = {
+          ...pending.graphSnapshot.checkpoint.channel_values.runtime,
+          ...resumeStatePatch
+        };
+    }
+    if (pending.graphSnapshot && frameworkAdapter)
+      await (0, import_runtime2.restoreGraphSnapshot)(
+        frameworkAdapter.checkpointer,
+        pending.graphSnapshot,
+        pending.runId
+      );
+    if (Object.keys(resumeDataPatch).length > 0) {
+      resumeUpdate.data = {
+        ...pendingData,
+        ...resumeDataPatch
+      };
+    }
+    if (resumeStatePatch) {
+      resumeUpdate.runtime = resumeStatePatch;
+    }
+    const hasResumeUpdate = !isLimitPause && Object.keys(resumeUpdate).length > 0;
+    const resumeValue = isLimitPause ? void 0 : meta.selected?.length && pending.schema.kind === "multi-choice" ? meta.selected.map((x) => String(x)) : meta.selected?.length ? String(meta.selected[0]) : void 0;
+    const resumeCheckpointId = typeof pending.graphCheckpointId === "string" && pending.graphCheckpointId.length > 0 ? pending.graphCheckpointId : void 0;
+    const resumedGraph = await (0, import_runtime2.createExecutionGraph)(wf, {
       ...telemetryConfig,
       resume: true,
-      telemetryInterruptId: pending.requestId,
-      telemetryInterruptNodeId: pending.node,
       ...resumeValue !== void 0 ? { resumeValue } : {},
       ...resumeCheckpointId ? { resumeCheckpointId } : {},
       ...hasResumeUpdate ? { resumeUpdate } : {}
+    });
+    await store.delete(pending.token);
+    const response = responseFromSelection(meta.selected);
+    const telemetry = isRecord4(telemetryConfig.telemetry) ? telemetryConfig.telemetry : {};
+    const responseCaptured = Boolean(
+      response && shouldCaptureTelemetryContent(telemetry.captureContent, "input")
+    );
+    emitTelemetryEvent({
+      config: telemetryConfig,
+      type: "interrupt.resolved",
+      correlation: {
+        runId: pending.runId,
+        sessionId,
+        workflowId,
+        nodeId: pending.node
+      },
+      payload: {
+        interruptId: pending.requestId,
+        resolvedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        resumeOutcome: "resumed",
+        responseCaptured,
+        ...responseCaptured && response ? { response } : {}
+      },
+      flush: true
+    });
+    const args = {
+      abortSignal,
+      emitOutput,
+      onOutcome,
+      sessionId,
+      runId: pending.runId,
+      graph: resumedGraph,
+      state: resumedState,
+      config: {
+        ...telemetryConfig,
+        resume: true,
+        telemetryInterruptId: pending.requestId,
+        telemetryInterruptNodeId: pending.node,
+        ...resumeValue !== void 0 ? { resumeValue } : {},
+        ...resumeCheckpointId ? { resumeCheckpointId } : {},
+        ...hasResumeUpdate ? { resumeUpdate } : {}
+      },
+      selectWorkflow,
+      knownWorkflowIds,
+      frameworkAdapter
+    };
+    const stream = await orchestrateGraphStream(args);
+    return stream;
+  } catch (error) {
+    await store.save(pending);
+    throw error;
+  }
+}
+
+// src/execution/execute.ts
+var handleSchema = import_zod3.z.object({
+  token: import_zod3.z.string().min(1),
+  requestId: import_zod3.z.string().min(1),
+  sessionId: import_zod3.z.string().min(1),
+  runId: import_zod3.z.string().min(1)
+}).strict();
+var responseSchema = import_zod3.z.discriminatedUnion("type", [
+  import_zod3.z.object({ type: import_zod3.z.literal("text"), text: import_zod3.z.string().min(1) }).strict(),
+  import_zod3.z.object({
+    type: import_zod3.z.literal("select"),
+    ids: import_zod3.z.array(import_zod3.z.string().min(1)).min(1)
+  }).strict(),
+  import_zod3.z.object({ type: import_zod3.z.literal("cancel") }).strict()
+]);
+function resultFromOutcome(outcome, runId, sessionId) {
+  const usage = outcome.pending?.schema.meta?.__kortyxResumeStatePatch?.tokenUsage ?? outcome.state.runtime?.tokenUsage;
+  const info = {
+    runId,
+    sessionId,
+    ...outcome.checkpointId ? { checkpointId: outcome.checkpointId } : {},
+    ...usage ? { usage } : {}
+  };
+  if ((0, import_core3.isExecutionCancelled)(outcome.error))
+    return { ...info, status: "cancelled", reason: "Execution cancelled." };
+  if (outcome.error) {
+    const error = outcome.error;
+    return {
+      ...info,
+      status: "failed",
+      error: {
+        code: typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : "EXECUTION_FAILED",
+        message: error instanceof Error ? error.message : String(error)
+      }
+    };
+  }
+  if (outcome.cancelled)
+    return { ...info, status: "cancelled", reason: "cancelled_by_client" };
+  if (outcome.pending) {
+    const pending = outcome.pending;
+    const meta = Object.fromEntries(
+      Object.entries(pending.schema.meta ?? {}).filter(
+        ([key]) => !key.startsWith("__kortyx")
+      )
+    );
+    return {
+      ...info,
+      status: "suspended",
+      ...pending.schema.meta?.__kortyxExecutionLimit ? {
+        reason: "limit_reached",
+        limit: pending.schema.meta.executionLimit
+      } : {},
+      interrupt: {
+        workflow: pending.workflow,
+        node: pending.node,
+        input: {
+          ...pending.schema,
+          meta,
+          options: pending.options.map(({ id, label, description }) => ({
+            id,
+            label,
+            description
+          }))
+        }
+      },
+      resume: {
+        token: pending.token,
+        requestId: pending.requestId,
+        sessionId,
+        runId
+      }
+    };
+  }
+  return { ...info, status: "completed", data: outcome.state.data ?? {} };
+}
+function runtimeConfig(services, sessionId, context) {
+  return {
+    session: { id: sessionId },
+    ...context ? { context } : {},
+    getProvider: services.getProvider,
+    checkpointer: services.frameworkAdapter.checkpointer,
+    selectWorkflow: (id) => services.registry.select(id),
+    ...services.telemetry ? { telemetry: services.telemetry } : {}
+  };
+}
+async function executeWorkflow(services, args) {
+  const select = (id) => services.registry.select(id);
+  const workflow = await resolveExecutionWorkflow(select, args.workflow);
+  const input = parseExecutionInput(workflow, args.input);
+  if (args.sessionId !== void 0 && !args.sessionId.trim())
+    throw new ExecutionRequestError(
+      "INVALID_SESSION",
+      "sessionId must not be empty."
+    );
+  const sessionId = args.sessionId ?? (0, import_runtime3.makeRequestId)("session");
+  const runId = (0, import_runtime3.makeRequestId)("run");
+  const config = prepareWorkflowTelemetry({
+    config: {
+      ...runtimeConfig(services, sessionId, args.context),
+      ...services.limits || args.limits ? {
+        executionBudget: (0, import_core3.createExecutionBudget)(
+          services.limits,
+          args.limits
+        )
+      } : {},
+      executionContract: { id: workflow.id, version: workflow.version }
     },
-    selectWorkflow,
-    knownWorkflowIds,
-    frameworkAdapter
+    workflow,
+    runId,
+    sessionId,
+    knownWorkflowIds: services.knownWorkflowIds
+  });
+  const state = await (0, import_runtime3.buildInitialGraphState)({
+    input,
+    runtime: {},
+    config,
+    defaultWorkflowId: workflow.id
+  });
+  return new Promise((resolve2) => {
+    const onOutcome = (outcome) => resolve2(resultFromOutcome(outcome, runId, sessionId));
+    void (async () => {
+      (0, import_core3.throwIfExecutionAborted)(args.abortSignal);
+      const graph = await (0, import_runtime3.createExecutionGraph)(workflow, config);
+      await orchestrateGraphStream({
+        graph,
+        state,
+        config,
+        runId,
+        sessionId,
+        selectWorkflow: select,
+        frameworkAdapter: services.frameworkAdapter,
+        knownWorkflowIds: services.knownWorkflowIds,
+        abortSignal: args.abortSignal,
+        emitOutput: false,
+        onOutcome
+      });
+    })().catch((error) => onOutcome({ state, error }));
+  });
+}
+async function resumeWorkflow(services, args) {
+  const parsed = import_zod3.z.object({ resume: handleSchema, response: responseSchema }).safeParse(args);
+  if (!parsed.success)
+    throw new ExecutionRequestError("INVALID_RESUME", parsed.error.message);
+  const { resume: handle, response } = parsed.data;
+  const select = (id) => services.registry.select(id);
+  const workflow = await resolveExecutionWorkflow(select, args.workflow);
+  const validatePending = async (pending) => {
+    const contract = pending.state?.config?.executionContract ?? {
+      id: pending.workflow
+    };
+    if (pending.runId !== handle.runId || contract.id !== workflow.id || contract.version && contract.version !== workflow.version)
+      throw new ExecutionRequestError(
+        "RESUME_MISMATCH",
+        "Resume handle does not match the root execution and workflow version."
+      );
+    if (response.type === "cancel") return;
+    if (response.type === "text") {
+      if (pending.schema.kind !== "text")
+        throw new ExecutionRequestError(
+          "INVALID_RESPONSE",
+          "This interrupt requires a selection."
+        );
+    } else {
+      const multi = pending.schema.kind === "multi-choice" || pending.schema.multiple;
+      if (pending.schema.kind === "text" || !multi && response.ids.length !== 1 || new Set(response.ids).size !== response.ids.length)
+        throw new ExecutionRequestError(
+          "INVALID_RESPONSE",
+          "Invalid selection for this interrupt."
+        );
+      if (pending.options.length && response.ids.some(
+        (id) => !pending.options.some((option) => option.id === id)
+      ))
+        throw new ExecutionRequestError(
+          "INVALID_RESPONSE",
+          "Selection contains an unknown option."
+        );
+    }
   };
-  const stream = await orchestrateGraphStream(args);
-  return stream;
+  return new Promise((resolve2, reject) => {
+    void tryPrepareResumeStream({
+      limits: args.limits,
+      abortSignal: args.abortSignal,
+      meta: {
+        token: handle.token,
+        requestId: handle.requestId,
+        selected: response.type === "text" ? [response.text] : response.type === "select" ? response.ids : [],
+        cancel: response.type === "cancel"
+      },
+      sessionId: handle.sessionId,
+      config: runtimeConfig(services, handle.sessionId),
+      selectWorkflow: select,
+      frameworkAdapter: services.frameworkAdapter,
+      knownWorkflowIds: services.knownWorkflowIds,
+      validatePending,
+      applyResumeSelection: () => ({}),
+      emitOutput: false,
+      onOutcome: (outcome) => resolve2(resultFromOutcome(outcome, handle.runId, handle.sessionId))
+    }).then((stream) => {
+      if (!stream)
+        reject(
+          new ExecutionRequestError(
+            "INVALID_RESUME",
+            "No waiting execution found."
+          )
+        );
+    }).catch(
+      (error) => reject(
+        error instanceof ExecutionRequestError ? error : new ExecutionRequestError(
+          "INVALID_RESUME",
+          error instanceof Error ? error.message : String(error)
+        )
+      )
+    );
+  });
+}
+
+// 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_runtime4 = require("@kortyx/runtime");
+
 // src/utils/extract-latest-message.ts
 function extractLatestUserMessage(messages) {
   if (!messages || messages.length === 0) return "";
@@ -1445,6 +4741,7 @@ function extractLatestUserMessage(messages) {
 // src/chat/process-chat.ts
 async function streamChat({
   messages,
+  abortSignal,
   options,
   sessionId,
   defaultWorkflowId,
@@ -1457,7 +4754,7 @@ async function streamChat({
   applyResumeSelection
 }) {
   const config = await loadRuntimeConfig(options);
-  let runtimeConfig = {
+  let runtimeConfig2 = {
     ...config,
     getProvider,
     ...frameworkAdapter ? { checkpointer: frameworkAdapter.checkpointer } : {}
@@ -1468,6 +4765,7 @@ async function streamChat({
       "streamChat requires selectWorkflow or workflowRegistry to resolve workflows."
     );
   }
+  runtimeConfig2.selectWorkflow = workflowSelector;
   const fallbackSessionId = options?.sessionId;
   const resolvedSessionId = sessionId || fallbackSessionId || "anonymous-session";
   const last = messages[messages.length - 1];
@@ -1489,16 +4787,11 @@ async function streamChat({
     if (requestedWorkflowId.trim() === "") delete runtime.requestedWorkflow;
     else runtime.requestedWorkflow = requestedWorkflowId;
   }
-  const baseState = await (0, import_runtime3.buildInitialGraphState)({
-    input,
-    config: runtimeConfig,
-    runtime,
-    ...defaultWorkflowId ? { defaultWorkflowId } : {}
-  });
   const resumeStream = await tryPrepareResumeStream({
+    abortSignal,
     lastMessage: last,
     sessionId: resolvedSessionId,
-    config: runtimeConfig,
+    config: runtimeConfig2,
     selectWorkflow: workflowSelector,
     knownWorkflowIds,
     ...frameworkAdapter ? { frameworkAdapter } : {},
@@ -1506,7 +4799,13 @@ async function streamChat({
     ...applyResumeSelection ? { applyResumeSelection } : {}
   });
   if (resumeStream) return resumeStream;
-  const runId = (0, import_runtime3.makeRequestId)("run");
+  const baseState = await (0, import_runtime4.buildInitialGraphState)({
+    input,
+    config: runtimeConfig2,
+    runtime,
+    ...defaultWorkflowId ? { defaultWorkflowId } : {}
+  });
+  const runId = (0, import_runtime4.makeRequestId)("run");
   let headCheckpoint = !isResumeRequest && frameworkAdapter?.sessionCheckpoints ? await frameworkAdapter.sessionCheckpoints.getHead(resolvedSessionId) : null;
   if (!isResumeRequest && !headCheckpoint && frameworkAdapter?.sessionCheckpoints) {
     headCheckpoint = await frameworkAdapter.sessionCheckpoints.append({
@@ -1526,18 +4825,26 @@ async function streamChat({
   }
   const currentWorkflow = requestedWorkflowId ? baseState.currentWorkflow : headCheckpoint?.state.currentWorkflow ?? baseState.currentWorkflow;
   const selectedWorkflow = await workflowSelector(currentWorkflow);
-  runtimeConfig = prepareWorkflowTelemetry({
-    config: runtimeConfig,
+  runtimeConfig2 = prepareWorkflowTelemetry({
+    config: runtimeConfig2,
     workflow: selectedWorkflow,
     runId,
     sessionId: resolvedSessionId,
     knownWorkflowIds
   });
-  const graph = await (0, import_runtime3.createExecutionGraph)(selectedWorkflow, runtimeConfig);
+  runtimeConfig2 = {
+    ...runtimeConfig2,
+    executionContract: {
+      id: selectedWorkflow.id,
+      version: selectedWorkflow.version
+    }
+  };
+  const parsedInput = selectedWorkflow.inputSchema ? parseExecutionInput(selectedWorkflow, input) : input;
+  const graph = await (0, import_runtime4.createExecutionGraph)(selectedWorkflow, runtimeConfig2);
   const initialState = headCheckpoint ? {
     ...headCheckpoint.state,
-    input,
-    config: runtimeConfig,
+    input: parsedInput,
+    config: runtimeConfig2,
     currentWorkflow,
     awaitingHumanInput: false,
     runtime: {
@@ -1545,13 +4852,19 @@ async function streamChat({
       ...runtime.requestedWorkflow ? { requestedWorkflow: runtime.requestedWorkflow } : {},
       ...runtime.priorMessages ? { priorMessages: runtime.priorMessages } : {}
     }
-  } : { ...baseState, config: runtimeConfig, currentWorkflow };
+  } : {
+    ...baseState,
+    input: parsedInput,
+    config: runtimeConfig2,
+    currentWorkflow
+  };
   const orchestratedStream = await orchestrateGraphStream({
+    abortSignal,
     sessionId: resolvedSessionId,
     runId,
     graph,
     state: initialState,
-    config: runtimeConfig,
+    config: runtimeConfig2,
     selectWorkflow: workflowSelector,
     knownWorkflowIds,
     ...frameworkAdapter ? { frameworkAdapter } : {}
@@ -1560,19 +4873,22 @@ async function streamChat({
 }
 
 // src/chat/create-agent.ts
-var agentProcessOptionsSchema = import_zod2.z.object({
-  sessionId: import_zod2.z.string().optional(),
-  workflowId: import_zod2.z.string().optional(),
-  context: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()).optional()
+var agentProcessOptionsSchema = import_zod4.z.object({
+  limits: import_core4.ExecutionLimitsSchema.optional(),
+  abortSignal: import_zod4.z.custom((value) => value instanceof AbortSignal).optional(),
+  sessionId: import_zod4.z.string().optional(),
+  workflowId: import_zod4.z.string().optional(),
+  context: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()).optional()
 }).strict();
-var createAgentArgsBaseSchema = import_zod2.z.object({
-  getProvider: import_zod2.z.unknown().optional(),
-  workflows: import_zod2.z.array(import_zod2.z.unknown()).optional(),
-  workflowsDir: import_zod2.z.string().optional(),
-  workflowRegistry: import_zod2.z.unknown().optional(),
-  defaultWorkflowId: import_zod2.z.string().optional(),
-  frameworkAdapter: import_zod2.z.unknown().optional(),
-  telemetry: import_zod2.z.unknown().optional()
+var createAgentArgsBaseSchema = import_zod4.z.object({
+  limits: import_core4.ExecutionLimitsSchema.optional(),
+  getProvider: import_zod4.z.unknown().optional(),
+  workflows: import_zod4.z.array(import_zod4.z.unknown()).optional(),
+  workflowsDir: import_zod4.z.string().optional(),
+  workflowRegistry: import_zod4.z.unknown().optional(),
+  defaultWorkflowId: import_zod4.z.string().optional(),
+  frameworkAdapter: import_zod4.z.unknown().optional(),
+  telemetry: import_zod4.z.unknown().optional()
 }).strict();
 var createAgentArgsSchema = createAgentArgsBaseSchema.superRefine(
   (value, ctx) => {
@@ -1617,7 +4933,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([
@@ -1636,6 +4952,7 @@ var clearPendingGraphWrites = async (frameworkAdapter, request) => {
 function createAgent(args) {
   const parsedArgs = parseCreateAgentArgs(args);
   const {
+    limits,
     getProvider,
     workflows,
     workflowsDir,
@@ -1645,24 +4962,24 @@ function createAgent(args) {
     telemetry
   } = parsedArgs;
   const resolvedDefaultWorkflowId = defaultWorkflowId;
-  const resolvedFrameworkAdapter = frameworkAdapter ?? (0, import_runtime4.createFrameworkAdapterFromEnv)();
+  const resolvedFrameworkAdapter = frameworkAdapter ?? (0, import_runtime5.createFrameworkAdapterFromEnv)();
   const resolvedGetProvider = getProvider ?? import_providers.getProvider;
   const resolvedCwd = process.cwd();
   const registryPromise = (async () => {
     if (workflowRegistry) return workflowRegistry;
     if (workflows) {
-      return (0, import_runtime4.createInMemoryWorkflowRegistry)(workflows, {
+      return (0, import_runtime5.createInMemoryWorkflowRegistry)(workflows, {
         fallbackId: resolvedDefaultWorkflowId ?? "general-chat"
       });
     }
     if (workflowsDir) {
-      return (0, import_runtime4.createFileWorkflowRegistry)({
+      return (0, import_runtime5.createFileWorkflowRegistry)({
         workflowsDir,
         fallbackId: resolvedDefaultWorkflowId ?? "general-chat"
       });
     }
     const resolvedWorkflowsDir = (0, import_node_path.resolve)(resolvedCwd, "src", "workflows");
-    return (0, import_runtime4.createFileWorkflowRegistry)({
+    return (0, import_runtime5.createFileWorkflowRegistry)({
       workflowsDir: resolvedWorkflowsDir,
       fallbackId: resolvedDefaultWorkflowId ?? "general-chat"
     });
@@ -1700,12 +5017,19 @@ function createAgent(args) {
     return streamChat({
       ...resolvedDefaultWorkflowId ? { defaultWorkflowId: resolvedDefaultWorkflowId } : {},
       messages,
+      abortSignal: parsedOptions?.abortSignal,
       options: parsedOptions,
       workflowRegistry: registry,
       ...knownWorkflowIds ? { knownWorkflowIds } : {},
       frameworkAdapter: resolvedFrameworkAdapter,
       getProvider: resolvedGetProvider,
       loadRuntimeConfig: (runtimeOptions) => ({
+        ...limits || runtimeOptions?.limits ? {
+          executionBudget: (0, import_core4.createExecutionBudget)(
+            limits,
+            runtimeOptions?.limits
+          )
+        } : {},
         ...runtimeOptions?.sessionId ? {
           session: {
             id: runtimeOptions.sessionId
@@ -1726,6 +5050,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 +5086,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 +5096,11 @@ function createAgent(args) {
         (request) => hydratePendingGraphCheckpoint(resolvedFrameworkAdapter, request)
       )
     );
+    restoreWorkflowCallBranch(
+      activePendingRequests,
+      telemetry,
+      source?.runId ?? "unknown"
+    );
     await Promise.all(
       activePendingRequests.map(
         (request) => clearPendingGraphWrites(resolvedFrameworkAdapter, request)
@@ -1795,7 +5130,25 @@ function createAgent(args) {
       checkpoint: { ...result.checkpoint, activePendingRequests }
     };
   };
+  const services = async () => {
+    const registry = await registryPromise;
+    if (!registry) throw new Error("Workflow registry is unavailable.");
+    return {
+      registry,
+      limits,
+      frameworkAdapter: resolvedFrameworkAdapter,
+      getProvider: resolvedGetProvider,
+      telemetry,
+      knownWorkflowIds: (await registeredWorkflowsPromise)?.map(
+        (workflow) => workflow.id
+      )
+    };
+  };
+  const execute = (async (options) => executeWorkflow(await services(), options));
+  const resume = (async (options) => resumeWorkflow(await services(), options));
   return {
+    execute,
+    resume,
     projectTopology,
     streamChat: streamChat2,
     listCheckpoints,
@@ -1806,6 +5159,7 @@ function createAgent(args) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ExecutionRequestError,
   createAgent,
   createChatRouteHandler,
   createCheckpointRouteHandler,