@kortyx/agent 0.16.0 → 0.18.0

package/dist/index.js

@@ -55,6 +55,7 @@ var require_dist = __commonJS({
       createWorkflowHooks: () => createWorkflowHooks,
       emitWorkflowCall: () => emitWorkflowCall2,
       runWithHookContext: () => runWithHookContext,
+      useAbortSignal: () => useAbortSignal,
       useInterrupt: () => useInterrupt,
       useNodeState: () => useNodeState,
       useReason: () => useReason2,
@@ -217,6 +218,7 @@ var require_dist = __commonJS({
       }
       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;
@@ -267,6 +269,7 @@ var require_dist = __commonJS({
     };
     var awaitInterruptInternal = (args) => {
       const ctx = getHookContext();
+      (0, import_core5.throwIfExecutionAborted)(ctx.node.abortSignal);
       const request = parseWithSchema(
         args.requestSchema,
         args.request,
@@ -299,6 +302,7 @@ var require_dist = __commonJS({
       );
       return Promise.resolve(response);
     };
+    var import_core52 = require("@kortyx/core");
     var import_node_crypto4 = require("crypto");
     var parseStructuredPath = (path, source) => {
       if (path.length === 0) {
@@ -386,7 +390,9 @@ var require_dist = __commonJS({
     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 {
@@ -413,6 +419,7 @@ var require_dist = __commonJS({
       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,
@@ -505,6 +512,7 @@ var require_dist = __commonJS({
           }
           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;
@@ -583,10 +591,12 @@ var require_dist = __commonJS({
             ...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
@@ -613,8 +623,9 @@ var require_dist = __commonJS({
         endTrace(traceSpan, result);
         return result;
       } catch (error) {
-        failTrace(traceSpan, error);
-        throw error;
+        const failure = abortSignal?.aborted ? (0, import_core22.createExecutionCancelledError)() : error;
+        failTrace(traceSpan, failure);
+        throw failure;
       }
     }
     var createRuntimeId2 = () => {
@@ -626,6 +637,13 @@ var require_dist = __commonJS({
     };
     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,
@@ -633,7 +651,7 @@ var require_dist = __commonJS({
         temperature: args.temperature,
         maxOutputTokens: args.maxOutputTokens,
         stopSequences: args.stopSequences,
-        abortSignal: args.abortSignal,
+        abortSignal,
         reasoning: args.reasoning,
         responseFormat: args.responseFormat,
         providerOptions: args.providerOptions,
@@ -815,7 +833,7 @@ var require_dist = __commonJS({
         ...output !== void 0 ? { output } : {}
       };
     };
-    var import_zod3 = require("zod");
+    var import_zod5 = require("zod");
     var tryStringify2 = (value) => {
       if (typeof value === "string") return value;
       try {
@@ -826,7 +844,7 @@ var require_dist = __commonJS({
     };
     var tryGetSchemaHint = (schema) => {
       try {
-        const hint = (0, import_zod3.toJSONSchema)(schema);
+        const hint = (0, import_zod5.toJSONSchema)(schema);
         return JSON.stringify(hint, null, 2);
       } catch {
         return void 0;
@@ -1574,6 +1592,7 @@ ${tryStringify2(args.response)}`
         ] : [];
       });
     };
+    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,
@@ -1627,6 +1646,11 @@ ${tryStringify2(args.response)}`
     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;
@@ -1676,6 +1700,7 @@ ${tryStringify2(args.response)}`
       };
       try {
         for (let stepIndex = 0; stepIndex < maxSteps; stepIndex += 1) {
+          (0, import_core42.throwIfExecutionAborted)(abortSignal);
           traceSpan?.addEvent?.("useReason.tool-step.start", {
             stepIndex,
             toolCount: toolDefinitions.length
@@ -1693,6 +1718,7 @@ ${tryStringify2(args.response)}`
           finalText = step.text;
           finalRaw = step.raw;
           aggregatedUsage = mergeUsage(aggregatedUsage, step.usage);
+          accumulateTokenUsage(step.usage);
           finalFinishReason = step.finishReason;
           aggregatedProviderMetadata = mergeProviderMetadata(
             aggregatedProviderMetadata,
@@ -1726,6 +1752,7 @@ ${tryStringify2(args.response)}`
             toolCalls
           });
           for (const toolCall of toolCalls) {
+            (0, import_core42.throwIfExecutionAborted)(abortSignal);
             const tool = toolByName.get(toolCall.name);
             if (!tool) {
               throw new Error(
@@ -1793,10 +1820,13 @@ ${tryStringify2(args.response)}`
               }
             }
             try {
+              (0, import_core42.throwIfExecutionAborted)(abortSignal);
+              ctx.node.consumeExecution?.("maxToolCalls");
               const rawResult = await tool.execute(toolCall.input, {
                 toolCallId: toolCall.id,
-                ...useReasonArgs.abortSignal ? { abortSignal: useReasonArgs.abortSignal } : {}
+                ...abortSignal ? { abortSignal } : {}
               });
+              (0, import_core42.throwIfExecutionAborted)(abortSignal);
               const result2 = normalizeToolResult(toolCall, rawResult);
               toolResults.push(result2);
               allToolResults.push(result2);
@@ -1816,6 +1846,9 @@ ${tryStringify2(args.response)}`
                 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,
@@ -1937,6 +1970,13 @@ ${tryStringify2(args.response)}`
     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({
@@ -2304,6 +2344,9 @@ ${tryStringify2(args.response)}`
     function useInterrupt(args) {
       return awaitInterruptInternal(args);
     }
+    function useAbortSignal() {
+      return getHookContext().node.abortSignal;
+    }
     function useRuntimeContext() {
       const ctx = getHookContext();
       const config = ctx.state.config;
@@ -2346,6 +2389,7 @@ ${tryStringify2(args.response)}`
       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;
@@ -2428,6 +2472,7 @@ ${tryStringify2(args.response)}`
     }
     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.");
@@ -2461,6 +2506,7 @@ ${tryStringify2(args.response)}`
           workflow,
           "call input or target changed during replay"
         );
+      if (!record) ctx.node.consumeExecution?.("maxChildInvocations");
       record ??= {
         fingerprint,
         invocationId: (0, import_node_crypto5.randomUUID)(),
@@ -2494,6 +2540,15 @@ ${tryStringify2(args.response)}`
           ...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) {
@@ -2522,14 +2577,28 @@ ${tryStringify2(args.response)}`
               ...record.interrupts.length ? { response: record.interrupts.at(-1)?.response } : {}
             });
           } catch (error) {
+            (0, import_core6.throwIfExecutionAborted)(ctx.node.abortSignal);
+            if ((0, import_core6.isExecutionCancelled)(error)) throw error;
+            if ((0, import_core6.isExecutionLimitReached)(error)) {
+              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;
-            accumulateTokenUsage(outcome.usage);
             workflowCallFingerprint(record.data);
             record.status = "completed";
             delete record.snapshot;
@@ -2569,6 +2638,7 @@ ${tryStringify2(args.response)}`
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  ExecutionRequestError: () => ExecutionRequestError,
   createAgent: () => createAgent,
   createChatRouteHandler: () => createChatRouteHandler,
   createCheckpointRouteHandler: () => createCheckpointRouteHandler,
@@ -2649,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
@@ -2668,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({
@@ -2734,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);
@@ -3008,134 +3241,6 @@ var prepareWorkflowTelemetry = (args) => {
   };
 };
 
-// src/telemetry/workflow-call-branch.ts
-var import_node_crypto3 = require("crypto");
-var import_hooks = __toESM(require_dist());
-function restoreWorkflowCallBranch(requests, telemetry, sourceRunId) {
-  const branchId = (0, import_node_crypto3.randomUUID)();
-  const emitted = /* @__PURE__ */ new Set();
-  for (const request of requests) {
-    if (request.state)
-      request.state.config = {
-        ...request.state.config,
-        executionBranchId: branchId
-      };
-    const seen = /* @__PURE__ */ new Set();
-    const visit = (value) => {
-      if (!value || typeof value !== "object" || seen.has(value)) return;
-      seen.add(value);
-      const record = value;
-      if (typeof record.invocationId === "string" && typeof record.fingerprint === "string" && Array.isArray(record.interrupts)) {
-        const previous = record.telemetry;
-        if (previous) {
-          record.sequence = 0;
-          record.telemetry = { ...previous, branchId };
-          if (!emitted.has(record.invocationId)) {
-            emitted.add(record.invocationId);
-            (0, import_hooks.emitWorkflowCall)(
-              telemetry ? {
-                ...telemetry,
-                correlation: {
-                  runId: request.runId,
-                  workflowId: request.workflow,
-                  ...request.sessionId ? { sessionId: request.sessionId } : {}
-                }
-              } : void 0,
-              "workflow.call.restored",
-              {
-                ...previous,
-                branchId,
-                sourceBranchId: previous.branchId,
-                sourceRunId,
-                sequence: 0,
-                status: record.status
-              }
-            );
-          }
-        }
-      }
-      for (const child of Object.values(record)) visit(child);
-    };
-    visit(request);
-  }
-  return branchId;
-}
-
-// src/chat/process-chat.ts
-var import_runtime3 = require("@kortyx/runtime");
-
-// 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;
-    }
-  }
-}
-
 // src/orchestrator.ts
 var isRecord3 = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
 var isGraphState = (value) => isRecord3(value) && typeof value.currentWorkflow === "string";
@@ -3157,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);
@@ -3206,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();
@@ -3217,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 {
   }
@@ -3241,6 +3361,7 @@ 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;
@@ -3248,8 +3369,10 @@ async function orchestrateGraphStream({
   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,
@@ -3258,7 +3381,10 @@ async function orchestrateGraphStream({
       if (graphSnapshot) {
         const sealed = { ...request, graphSnapshot };
         activePendingRequests.set(token, sealed);
-        await pendingStore?.update(token, { graphSnapshot });
+        await pendingStore?.update(token, {
+          graphSnapshot,
+          state: request.state
+        });
       }
     }
   };
@@ -3309,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);
@@ -3318,7 +3445,7 @@ async function orchestrateGraphStream({
         ([key]) => !key.startsWith("__kortyx")
       )
     ) : void 0;
-    out.write({
+    write({
       type: "interrupt",
       requestId: record.requestId,
       resumeToken: record.token,
@@ -3380,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;
@@ -3394,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 } : {},
@@ -3416,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,
@@ -3430,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 } : {},
@@ -3444,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,
@@ -3461,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,
@@ -3480,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,
@@ -3496,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") {
@@ -3505,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,
@@ -3531,7 +3659,7 @@ async function orchestrateGraphStream({
       return;
     }
     if (event === "transition") {
-      out.write({
+      write({
         type: "transition",
         transitionTo: payload?.transitionTo,
         payload: payload?.payload ?? {}
@@ -3559,10 +3687,14 @@ 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;
@@ -3595,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}`
         });
@@ -3614,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);
@@ -3633,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;
@@ -3677,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
@@ -3687,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
@@ -3700,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;
         }
@@ -3737,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(
@@ -3753,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,
@@ -3775,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,
@@ -3793,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);
       }
@@ -3835,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,
@@ -3853,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;
     }
@@ -3868,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,
@@ -3884,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;
 }
@@ -3924,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,
@@ -3933,7 +4271,7 @@ 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;
@@ -3945,6 +4283,24 @@ async function tryPrepareResumeStream({
   }
   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) {
@@ -3964,125 +4320,412 @@ async function tryPrepareResumeStream({
       },
       flush: true
     });
+    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: {
-      ...config,
-      ...pending.state?.config?.executionBranchId ? { executionBranchId: pending.state.config.executionBranchId } : {}
-    },
-    workflow: wf,
-    runId: pending.runId,
-    sessionId,
-    knownWorkflowIds
-  });
-  resumedState.config = telemetryConfig;
-  const resumeUpdate = pending.graphSnapshot ? {
-    config: {
-      ...telemetryConfig,
-      context: pending.state?.config?.context ?? telemetryConfig.context
-    }
-  } : {};
-  if (pending.graphSnapshot && frameworkAdapter)
-    await (0, import_runtime2.restoreGraphSnapshot)(
-      frameworkAdapter.checkpointer,
-      pending.graphSnapshot,
-      pending.runId
-    );
-  if (Object.keys(resumeDataPatch).length > 0) {
-    resumeUpdate.data = {
-      ...pendingData,
-      ...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 "";
@@ -4098,6 +4741,7 @@ function extractLatestUserMessage(messages) {
 // src/chat/process-chat.ts
 async function streamChat({
   messages,
+  abortSignal,
   options,
   sessionId,
   defaultWorkflowId,
@@ -4110,7 +4754,7 @@ async function streamChat({
   applyResumeSelection
 }) {
   const config = await loadRuntimeConfig(options);
-  let runtimeConfig = {
+  let runtimeConfig2 = {
     ...config,
     getProvider,
     ...frameworkAdapter ? { checkpointer: frameworkAdapter.checkpointer } : {}
@@ -4121,7 +4765,7 @@ async function streamChat({
       "streamChat requires selectWorkflow or workflowRegistry to resolve workflows."
     );
   }
-  runtimeConfig.selectWorkflow = workflowSelector;
+  runtimeConfig2.selectWorkflow = workflowSelector;
   const fallbackSessionId = options?.sessionId;
   const resolvedSessionId = sessionId || fallbackSessionId || "anonymous-session";
   const last = messages[messages.length - 1];
@@ -4143,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 } : {},
@@ -4160,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({
@@ -4180,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: {
@@ -4199,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 } : {}
@@ -4214,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) => {
@@ -4290,6 +4952,7 @@ var clearPendingGraphWrites = async (frameworkAdapter, request) => {
 function createAgent(args) {
   const parsedArgs = parseCreateAgentArgs(args);
   const {
+    limits,
     getProvider,
     workflows,
     workflowsDir,
@@ -4299,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"
     });
@@ -4354,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
@@ -4460,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,
@@ -4471,6 +5159,7 @@ function createAgent(args) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ExecutionRequestError,
   createAgent,
   createChatRouteHandler,
   createCheckpointRouteHandler,