@kortyx/agent 0.23.0 → 0.25.0

package/dist/index.js

@@ -29,6 +29,448 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// ../hooks/dist/internal.js
+var require_internal = __commonJS({
+  "../hooks/dist/internal.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 internal_exports = {};
+    __export2(internal_exports, {
+      errorDiagnostics: () => errorDiagnostics,
+      isModelTraceSpan: () => isModelTraceSpan,
+      runReasonEngine: () => runReasonEngine,
+      safeSpan: () => safeSpan,
+      safeStartSpan: () => safeStartSpan2,
+      safeTelemetryMetadata: () => safeTelemetryMetadata2,
+      withSafeTraceSpan: () => withSafeTraceSpan2
+    });
+    module2.exports = __toCommonJS2(internal_exports);
+    var import_errors6 = require("@kortyx/core/errors");
+    function errorDiagnostics(error, project) {
+      try {
+        const name = (0, import_errors6.errorProperty)(error, "name") ?? (error instanceof Error ? error.name : void 0);
+        const message = (0, import_errors6.errorProperty)(error, "message");
+        const details = project ? project(error) : {
+          type: typeof name === "string" ? name : "Error",
+          message: typeof error === "string" ? error : typeof message === "string" ? message : "Execution reported a fault."
+        };
+        if (!details) return {};
+        const projectedMessage = details.message;
+        const projectedType = details.type;
+        if (typeof projectedMessage !== "string") return {};
+        return {
+          errorMessage: projectedMessage.slice(0, 8192),
+          ...typeof projectedType === "string" ? { errorType: projectedType.slice(0, 256) } : {}
+        };
+      } catch {
+        return {};
+      }
+    }
+    function isModelTraceSpan(name) {
+      return name === "runReasonEngine" || name === "useReason";
+    }
+    var import_node_crypto4 = require("crypto");
+    var import_core6 = require("@kortyx/core");
+    var import_errors22 = require("@kortyx/core/errors");
+    function safeSpan(span) {
+      const guard = (fn) => (...args) => {
+        try {
+          fn?.(...args);
+        } catch {
+        }
+      };
+      let ended = false;
+      const finish = (fn) => (...args) => {
+        if (ended) return;
+        ended = true;
+        guard(fn)(...args);
+      };
+      return {
+        addEvent: guard(
+          (name, attributes) => span?.addEvent?.(name, attributes)
+        ),
+        setAttributes: guard(
+          (attributes) => span?.setAttributes?.(attributes)
+        ),
+        end: finish((args) => span?.end?.(args)),
+        fail: finish((error, args) => {
+          if (span?.fail) span.fail(error, args);
+          else span?.end?.(args);
+        })
+      };
+    }
+    function safeStartSpan2(adapter, args) {
+      try {
+        return safeSpan(adapter?.startSpan?.(args));
+      } catch {
+        return safeSpan(void 0);
+      }
+    }
+    async function withSafeTraceSpan2(adapter, args, fn) {
+      let execution;
+      const invoke = (span) => {
+        execution ??= Promise.resolve().then(async () => {
+          const observed = safeSpan(span);
+          try {
+            const result = await fn(observed);
+            observed.end?.();
+            return result;
+          } catch (error) {
+            observed.fail?.(error);
+            throw error;
+          }
+        });
+        return execution;
+      };
+      let activeScope;
+      try {
+        activeScope = adapter?.withSpan?.bind(adapter);
+      } catch {
+      }
+      if (activeScope) {
+        let started;
+        const invoked = new Promise((resolve2) => {
+          started = resolve2;
+        });
+        const observe = async () => {
+          try {
+            await activeScope(args, (span) => {
+              const result = invoke(span);
+              started?.();
+              return result;
+            });
+          } catch {
+          }
+        };
+        const observation = observe();
+        if (!execution) await Promise.race([invoked, observation]);
+      } else {
+        await invoke(safeStartSpan2(adapter, args)).catch(() => {
+        });
+      }
+      return execution ?? invoke(safeSpan(void 0));
+    }
+    function assertModelFinish(result) {
+      if (result.finishReason?.unified !== "content-filter") return;
+      throw Object.assign(
+        new import_errors22.KortyxError("PROVIDER_REFUSAL", "The provider refused the request.", {
+          category: "provider",
+          retryable: false,
+          safeMessage: "The provider refused the request."
+        }),
+        {
+          ...result.usage ? { usage: result.usage } : {},
+          finishReason: result.finishReason
+        }
+      );
+    }
+    var toError = (value) => value instanceof Error ? value : new Error(String(value));
+    var createRuntimeId = () => {
+      try {
+        return (0, import_node_crypto4.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 } : {}
+      });
+    };
+    var resolveProviderOptions = (defaults, overrides) => {
+      const providerOptions = defaults || overrides ? { ...defaults, ...overrides } : void 0;
+      for (const [key, value] of Object.entries(overrides ?? {})) {
+        const previous = defaults?.[key];
+        if (previous && value && typeof previous === "object" && typeof value === "object" && !Array.isArray(previous) && !Array.isArray(value)) {
+          if (providerOptions) providerOptions[key] = { ...previous, ...value };
+        }
+      }
+      return providerOptions;
+    };
+    async function runReasonEngine(args) {
+      let stream = args.stream ?? args.model.options?.streaming ?? true;
+      const emit = args.emit ?? true;
+      const temperature = args.temperature ?? args.model.options?.temperature ?? args.defaultTemperature;
+      const maxOutputTokens = args.maxOutputTokens ?? args.model.options?.maxOutputTokens;
+      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 = resolveProviderOptions(
+        args.model.options?.providerOptions,
+        args.providerOptions
+      );
+      const tools = args.tools ?? args.model.options?.tools;
+      (0, import_core6.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 } : {}
+      });
+      if (tools?.length && !model.supportsToolStreaming) stream = false;
+      const messages = args.messages !== void 0 ? args.messages : [
+        ...typeof args.system === "string" && args.system.length > 0 ? [{ role: "system", content: args.system }] : [],
+        { role: "user", content: String(args.input ?? "") }
+      ];
+      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 = safeStartSpan2(args.reasonTrace, {
+        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.map(
+            ({ continuation: _continuation, raw: _raw, ...message }) => message
+          )
+        }
+      });
+      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) => {
+        const detail = error;
+        try {
+          span?.fail?.(error, {
+            ...detail?.usage ? { usage: detail.usage } : {},
+            ...detail?.finishReason ? { finishReason: detail.finishReason } : {},
+            ...detail?.providerMetadata ? { providerMetadata: detail.providerMetadata } : {},
+            attributes: {
+              providerId: args.model.provider.id,
+              modelId: args.model.modelId
+            }
+          });
+        } catch {
+        }
+      };
+      try {
+        if (stream) {
+          let continuation;
+          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_core6.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": {
+                continuation = chunk.continuation;
+                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);
+              }
+            }
+          }
+          (0, import_core6.throwIfExecutionAborted)(abortSignal);
+          assertModelFinish({ finishReason, usage });
+          if (emit) {
+            emitNodeEvent(args.emitEvent, args.nodeId, "text-end", {
+              ...commonMeta
+            });
+          }
+          const result2 = {
+            text: final,
+            ...continuation ? { continuation } : {},
+            ...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_core6.throwIfExecutionAborted)(abortSignal);
+          endTrace(traceSpan, result2);
+          return result2;
+        }
+        const response = await model.invoke(messages);
+        (0, import_core6.throwIfExecutionAborted)(abortSignal);
+        assertModelFinish(response);
+        if (response.content) args.onTextChunk?.(response.content);
+        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.continuation ? { continuation: response.continuation } : {},
+          ...response.raw !== void 0 ? { raw: response.raw } : {},
+          ...response.usage !== void 0 ? { usage: response.usage } : {},
+          ...response.finishReason !== void 0 ? { finishReason: response.finishReason } : {},
+          ...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_core6.createExecutionCancelledError)() : error;
+        failTrace(traceSpan, failure);
+        throw failure;
+      }
+    }
+    var privateField = /^(?:password|passwd|secret|clientsecret|privatekey|credential|credentials|authorization|bearer|bearertoken|jwt|token|accesstoken|refreshtoken|authtoken|apikey|apisecret|cookie|setcookie|resumehandle|resumetoken)$/;
+    function safeTelemetryMetadata2(value) {
+      const seen = /* @__PURE__ */ new WeakSet();
+      const visit = (input, depth) => {
+        if (depth > 8 || typeof input === "function" || typeof input === "symbol")
+          return void 0;
+        if (!input || typeof input !== "object") return input;
+        if (seen.has(input)) return void 0;
+        seen.add(input);
+        if (Array.isArray(input))
+          return input.map((item) => visit(item, depth + 1));
+        return Object.fromEntries(
+          Object.entries(input).flatMap(
+            ([key, nested]) => privateField.test(key.toLowerCase().replace(/[^a-z0-9]/g, "")) ? [] : [[key, visit(nested, depth + 1)]]
+          )
+        );
+      };
+      try {
+        return visit(value, 0);
+      } catch {
+        return {};
+      }
+    }
+  }
+});
+
 // ../hooks/dist/index.js
 var require_dist = __commonJS({
   "../hooks/dist/index.js"(exports2, module2) {
@@ -64,6 +506,7 @@ var require_dist = __commonJS({
       useReason: () => useReason2,
       useRuntimeContext: () => useRuntimeContext,
       useStructuredData: () => useStructuredData,
+      useTool: () => useTool,
       useWorkflow: () => useWorkflow,
       useWorkflowState: () => useWorkflowState,
       workflowCallFingerprint: () => workflowCallFingerprint
@@ -127,6 +570,7 @@ var require_dist = __commonJS({
         workflowContextClosed: false,
         nodeStateIndex: 0,
         reasonCallIndex: 0,
+        toolCallIndex: 0,
         currentNodeState,
         workflowState: cloneWorkflowState(hookRuntimeState.workflowState),
         tokenUsage: cloneTokenUsage(ctx.state.runtime?.tokenUsage),
@@ -217,6 +661,12 @@ var require_dist = __commonJS({
           }
         });
         cleanupCompletedReasonCheckpoints(internal);
+        for (const key of Object.keys(internal.currentNodeState.byKey)) {
+          if (key.startsWith("__useTool:")) {
+            delete internal.currentNodeState.byKey[key];
+            internal.stateDirty = true;
+          }
+        }
         for (const key of Object.keys(internal.currentNodeState.byKey)) {
           if (key.startsWith("__useWorkflow:") || key.startsWith("__parallel:") || key === "__useWorkflowActivation") {
             internal.currentNodeState.byKey[key] = null;
@@ -347,17 +797,95 @@ var require_dist = __commonJS({
             ...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_core62 = require("@kortyx/core");
+    function safeSpan(span) {
+      const guard = (fn) => (...args) => {
+        try {
+          fn?.(...args);
+        } catch {
+        }
+      };
+      let ended = false;
+      const finish = (fn) => (...args) => {
+        if (ended) return;
+        ended = true;
+        guard(fn)(...args);
+      };
+      return {
+        addEvent: guard(
+          (name, attributes) => span?.addEvent?.(name, attributes)
+        ),
+        setAttributes: guard(
+          (attributes) => span?.setAttributes?.(attributes)
+        ),
+        end: finish((args) => span?.end?.(args)),
+        fail: finish((error, args) => {
+          if (span?.fail) span.fail(error, args);
+          else span?.end?.(args);
+        })
+      };
+    }
+    function safeStartSpan2(adapter, args) {
+      try {
+        return safeSpan(adapter?.startSpan?.(args));
+      } catch {
+        return safeSpan(void 0);
+      }
+    }
+    async function withSafeTraceSpan2(adapter, args, fn) {
+      let execution;
+      const invoke = (span) => {
+        execution ??= Promise.resolve().then(async () => {
+          const observed = safeSpan(span);
+          try {
+            const result = await fn(observed);
+            observed.end?.();
+            return result;
+          } catch (error) {
+            observed.fail?.(error);
+            throw error;
+          }
+        });
+        return execution;
       };
-      const raw = ctx.node.awaitInterrupt(enrichedRequest);
-      const response = parseWithSchema(
-        args.responseSchema,
-        raw,
-        "useInterrupt response"
-      );
-      return Promise.resolve(response);
-    };
-    var import_core52 = require("@kortyx/core");
+      let activeScope;
+      try {
+        activeScope = adapter?.withSpan?.bind(adapter);
+      } catch {
+      }
+      if (activeScope) {
+        let started;
+        const invoked = new Promise((resolve2) => {
+          started = resolve2;
+        });
+        const observe = async () => {
+          try {
+            await activeScope(args, (span) => {
+              const result = invoke(span);
+              started?.();
+              return result;
+            });
+          } catch {
+          }
+        };
+        const observation = observe();
+        if (!execution) await Promise.race([invoked, observation]);
+      } else {
+        await invoke(safeStartSpan2(adapter, args)).catch(() => {
+        });
+      }
+      return execution ?? invoke(safeSpan(void 0));
+    }
     var import_node_crypto4 = require("crypto");
     var parseStructuredPath = (path, source) => {
       if (path.length === 0) {
@@ -444,15 +972,381 @@ var require_dist = __commonJS({
     };
     var shouldEmitStructured = (cfg) => Boolean(cfg);
     var shouldStreamStructured = (cfg) => Boolean(cfg) && (cfg?.stream ?? true);
+    var import_node_async_hooks2 = require("async_hooks");
     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 import_errors32 = require("@kortyx/core/errors");
     var import_errors22 = require("@kortyx/core/errors");
+    function errorDiagnostics(error, project) {
+      try {
+        const name = (0, import_errors22.errorProperty)(error, "name") ?? (error instanceof Error ? error.name : void 0);
+        const message = (0, import_errors22.errorProperty)(error, "message");
+        const details = project ? project(error) : {
+          type: typeof name === "string" ? name : "Error",
+          message: typeof error === "string" ? error : typeof message === "string" ? message : "Execution reported a fault."
+        };
+        if (!details) return {};
+        const projectedMessage = details.message;
+        const projectedType = details.type;
+        if (typeof projectedMessage !== "string") return {};
+        return {
+          errorMessage: projectedMessage.slice(0, 8192),
+          ...typeof projectedType === "string" ? { errorType: projectedType.slice(0, 256) } : {}
+        };
+      } catch {
+        return {};
+      }
+    }
+    var import_node_crypto22 = 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_crypto22.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 tools = new import_node_async_hooks2.AsyncLocalStorage();
+    function classification(tool, value, thrown, policy = tool.outcomes) {
+      const fallback = {
+        outcome: thrown ? "fault" : "success"
+      };
+      try {
+        if (value && typeof value === "object" && "isError" in value && value.isError === true)
+          fallback.outcome = "fault";
+        const result = thrown ? policy?.classifyError?.(value) : policy?.classifyResult?.(value);
+        if (!result || !["success", "denied", "fault"].includes(result.outcome))
+          return fallback;
+        if (result.outcome !== "denied")
+          return thrown || fallback.outcome === "fault" ? fallback : { outcome: result.outcome };
+        const code = result.code;
+        return {
+          outcome: "denied",
+          code: typeof code === "string" && /^[A-Z][A-Z0-9_]{0,63}$/.test(code) && policy?.denialCodes?.includes(code) ? code : "DENIED"
+        };
+      } catch {
+        return fallback;
+      }
+    }
+    async function closeOwnedTools(owned) {
+      const closers = /* @__PURE__ */ new Map();
+      for (const tool of owned) {
+        if (tool.closeAfterUse !== false && tool.close && !closers.has(tool.close))
+          closers.set(tool.close, tool);
+      }
+      await Promise.all(
+        [...closers].map(async ([close, tool]) => {
+          try {
+            await close.call(tool);
+          } catch {
+            const ctx = getHookContext();
+            try {
+              ctx.reasonTrace?.startSpan({
+                name: "kortyx.tool.cleanup",
+                attributes: { cleanupFailed: true }
+              })?.end?.();
+            } catch {
+            }
+          }
+        })
+      );
+    }
+    function captureToolError(observation, error, policy, returned = false) {
+      try {
+        const reported = returned && error && typeof error === "object" && "isError" in error && error.isError === true && "content" in error && typeof error.content === "string" ? { name: "ToolError", message: error.content } : error;
+        Object.assign(
+          observation,
+          errorDiagnostics(policy?.error ? error : reported, policy?.error)
+        );
+      } catch {
+      }
+    }
+    function ownership() {
+      const ctx = getHookContext();
+      const correlation = ctx.node.workflowCallTelemetry?.correlation;
+      return {
+        workflowId: ctx.node.graph.name,
+        nodeId: ctx.node.graph.node,
+        ...correlation?.workflowRevisionId ? { workflowRevisionId: correlation.workflowRevisionId } : {},
+        ...correlation?.parentInvocationId ? { parentInvocationId: correlation.parentInvocationId } : {},
+        ...correlation?.runId ? { runId: correlation.runId } : {},
+        ...correlation?.invocationId ? { invocationId: correlation.invocationId } : {},
+        ...correlation?.branchId ? { branchId: correlation.branchId } : {}
+      };
+    }
+    function rememberToolObservation(observation) {
+      const ctx = getHookContext();
+      const existing = ctx.workflowState.__kortyxToolObservations;
+      const observations = Array.isArray(existing) ? existing : [];
+      if (!observations.some((item) => item.attemptId === observation.attemptId))
+        observations.push({ ...observation });
+      ctx.workflowState.__kortyxToolObservations = observations;
+      ctx.stateDirty = true;
+    }
+    function toolTrace(observation) {
+      const ctx = getHookContext();
+      const adapter = ctx.reasonTrace ?? ctx.node.workflowCallTelemetry?.trace;
+      if (adapter) return adapter;
+      const telemetry = ctx.node.workflowCallTelemetry;
+      if (!telemetry?.reporter) return void 0;
+      const correlation = { ...telemetry.correlation, ...observation };
+      const spanId = (0, import_node_crypto32.randomUUID)();
+      const emit = (type, payload) => emitWorkflowCall2(
+        {
+          ...telemetry,
+          correlation,
+          trace: {
+            startSpan: () => void 0,
+            getActiveContext: () => ({
+              traceId: correlation.runId ?? spanId,
+              spanId
+            })
+          }
+        },
+        type,
+        payload
+      );
+      return {
+        startSpan: ({ attributes = {} }) => {
+          if (attributes.executed === true) emit("tool.started", attributes);
+          let ended = false;
+          return {
+            end: (args) => {
+              if (ended) return;
+              ended = true;
+              const payload = { ...attributes, ...args?.attributes };
+              const type = payload.observationKind === "reused" ? "tool.reused" : payload.observationKind === "waiting" ? "tool.waiting" : payload.suspended ? "tool.suspended" : payload.outcome === "denied" ? "tool.denied" : payload.outcome === "fault" ? "tool.failed" : payload.outcome === "cancelled" ? "tool.cancelled" : "tool.completed";
+              emit(type, payload);
+            }
+          };
+        }
+      };
+    }
+    async function executeObservedTool(args) {
+      const ctx = getHookContext();
+      const observation = {
+        version: 1,
+        name: args.tool.name,
+        toolCallId: args.toolCallId,
+        attemptId: (0, import_node_crypto32.randomUUID)(),
+        callingMode: args.callingMode,
+        executed: false,
+        ...ownership()
+      };
+      const scope = {
+        tool: args.tool,
+        input: args.input,
+        signal: args.abortSignal,
+        mode: args.callingMode,
+        providerToolCallId: args.providerToolCallId ?? args.toolCallId,
+        adopted: false
+      };
+      try {
+        (0, import_core22.throwIfExecutionAborted)(args.abortSignal);
+      } catch (error) {
+        observation.outcome = "cancelled";
+        await observeToolFact(observation);
+        args.onObservation?.(observation);
+        throw error;
+      }
+      ctx.node.consumeExecution?.("maxToolCalls");
+      observation.executed = true;
+      const started = performance.now();
+      return withSafeTraceSpan2(
+        toolTrace(observation),
+        {
+          name: "kortyx.tool",
+          attributes: { ...observation, nodeId: ctx.node.graph.node }
+        },
+        async (span) => tools.run(scope, async () => {
+          try {
+            const result = await args.tool.execute(args.input, {
+              toolCallId: args.providerToolCallId ?? args.toolCallId,
+              ...args.abortSignal ? { abortSignal: args.abortSignal } : {}
+            });
+            (0, import_core22.throwIfExecutionAborted)(args.abortSignal);
+            const outcome = classification(
+              args.tool,
+              result,
+              false,
+              scope.classify ?? args.tool.outcomes
+            );
+            observation.outcome = outcome.outcome;
+            if (outcome.code) observation.denialCode = outcome.code;
+            if (observation.outcome === "fault") {
+              captureToolError(
+                observation,
+                result,
+                scope.telemetry ?? args.tool.telemetry,
+                true
+              );
+            }
+            return result;
+          } catch (error) {
+            if (args.abortSignal?.aborted) observation.outcome = "cancelled";
+            else if (!(0, import_errors32.isControlFlowError)(error)) {
+              const outcome = classification(
+                args.tool,
+                error,
+                true,
+                scope.classify ?? args.tool.outcomes
+              );
+              observation.outcome = outcome.outcome;
+              if (outcome.code) observation.denialCode = outcome.code;
+              if (observation.outcome === "fault")
+                captureToolError(
+                  observation,
+                  error,
+                  scope.telemetry ?? args.tool.telemetry
+                );
+            }
+            throw error;
+          } finally {
+            observation.durationMs = Math.max(0, performance.now() - started);
+            span.end?.({
+              attributes: {
+                ...observation,
+                ...observation.outcome ? {} : { suspended: true }
+              }
+            });
+            rememberToolObservation(observation);
+            args.onObservation?.({ ...observation });
+          }
+        })
+      );
+    }
+    async function observeToolFact(observation, kind, preserveOwner = false) {
+      const ctx = getHookContext();
+      if (!preserveOwner) Object.assign(observation, ownership());
+      if (observation.outcome && kind !== "reused")
+        rememberToolObservation(observation);
+      await withSafeTraceSpan2(
+        toolTrace(observation),
+        {
+          name: "kortyx.tool",
+          attributes: {
+            ...observation,
+            executed: false,
+            ...kind ? { observationKind: kind } : {},
+            nodeId: observation.nodeId ?? ctx.node.graph.node
+          }
+        },
+        async (span) => {
+          span.end?.({
+            attributes: {
+              ...observation,
+              executed: false,
+              ...kind ? { observationKind: kind } : {}
+            }
+          });
+        }
+      );
+    }
+    async function useTool(args) {
+      const ctx = getHookContext();
+      const scope = tools.getStore();
+      if (scope?.mode === "model" && !scope.adopted && scope.tool.name === args.tool.name && scope.input === args.input) {
+        scope.adopted = true;
+        scope.classify = args.tool.outcomes ?? scope.classify;
+        scope.telemetry = args.tool.telemetry ?? scope.telemetry;
+        return tools.run(
+          { ...scope, mode: "direct" },
+          () => args.tool.execute(args.input, {
+            toolCallId: scope.providerToolCallId,
+            ...scope.signal ? { abortSignal: scope.signal } : {}
+          })
+        );
+      }
+      const index = ctx.toolCallIndex++;
+      const key = `__useTool:${args.id ?? `auto:${index}`}`;
+      let id = ctx.currentNodeState.byKey[key];
+      if (typeof id !== "string") {
+        id = (0, import_node_crypto32.randomUUID)();
+        ctx.currentNodeState.byKey[key] = id;
+        ctx.stateDirty = true;
+      }
+      try {
+        return await executeObservedTool({
+          tool: args.tool,
+          input: args.input,
+          toolCallId: String(id),
+          callingMode: "direct",
+          abortSignal: (0, import_core22.combineAbortSignals)(ctx.node.abortSignal, args.abortSignal)
+        });
+      } finally {
+        await closeOwnedTools([args.tool]);
+      }
+    }
+    async function replayToolObservations(observations, child = false) {
+      for (const original of observations) {
+        const source = original.source ?? {
+          ...ownershipFrom(original),
+          toolCallId: original.toolCallId,
+          attemptId: original.attemptId
+        };
+        await observeToolFact(
+          {
+            ...original,
+            ...ownership(),
+            ...child ? {
+              workflowId: original.workflowId,
+              nodeId: original.nodeId,
+              workflowRevisionId: original.workflowRevisionId,
+              invocationId: original.invocationId,
+              parentInvocationId: original.parentInvocationId
+            } : {},
+            attemptId: (0, import_node_crypto32.randomUUID)(),
+            executed: false,
+            source,
+            durationMs: void 0
+          },
+          "reused",
+          child
+        );
+      }
+    }
+    var ownershipFrom = (observation) => ({
+      runId: observation.runId,
+      invocationId: observation.invocationId,
+      branchId: observation.branchId
+    });
+    var import_node_crypto5 = require("crypto");
+    var import_core42 = require("@kortyx/core");
+    var import_node_crypto42 = require("crypto");
+    var import_core32 = require("@kortyx/core");
+    var import_errors42 = require("@kortyx/core/errors");
     function assertModelFinish(result) {
       if (result.finishReason?.unified !== "content-filter") return;
       throw Object.assign(
-        new import_errors22.KortyxError("PROVIDER_REFUSAL", "The provider refused the request.", {
+        new import_errors42.KortyxError("PROVIDER_REFUSAL", "The provider refused the request.", {
           category: "provider",
           retryable: false,
           safeMessage: "The provider refused the request."
@@ -466,7 +1360,7 @@ var require_dist = __commonJS({
     var toError = (value) => value instanceof Error ? value : new Error(String(value));
     var createRuntimeId = () => {
       try {
-        return (0, import_node_crypto22.randomUUID)();
+        return (0, import_node_crypto42.randomUUID)();
       } catch {
         return `${Date.now()}-${Math.random().toString(36).slice(2)}`;
       }
@@ -501,8 +1395,8 @@ var require_dist = __commonJS({
         args.model.options?.providerOptions,
         args.providerOptions
       );
-      const tools = args.tools ?? args.model.options?.tools;
-      (0, import_core22.throwIfExecutionAborted)(abortSignal);
+      const tools2 = args.tools ?? args.model.options?.tools;
+      (0, import_core32.throwIfExecutionAborted)(abortSignal);
       const model = args.model.provider.getModel(args.model.modelId, {
         ...temperature !== void 0 ? { temperature } : {},
         streaming: stream,
@@ -511,10 +1405,10 @@ var require_dist = __commonJS({
         ...abortSignal !== void 0 ? { abortSignal } : {},
         ...reasoning !== void 0 ? { reasoning } : {},
         ...responseFormat !== void 0 ? { responseFormat } : {},
-        ...tools !== void 0 ? { tools } : {},
+        ...tools2 !== void 0 ? { tools: tools2 } : {},
         ...providerOptions !== void 0 ? { providerOptions } : {}
       });
-      if (tools?.length && !model.supportsToolStreaming) stream = false;
+      if (tools2?.length && !model.supportsToolStreaming) stream = false;
       const messages = args.messages !== void 0 ? args.messages : [
         ...typeof args.system === "string" && args.system.length > 0 ? [{ role: "system", content: args.system }] : [],
         { role: "user", content: String(args.input ?? "") }
@@ -526,7 +1420,7 @@ var require_dist = __commonJS({
         opId,
         segmentId
       };
-      const traceSpan = args.reasonTrace?.startSpan({
+      const traceSpan = safeStartSpan2(args.reasonTrace, {
         name: "runReasonEngine",
         attributes: {
           ...commonMeta,
@@ -606,7 +1500,7 @@ var require_dist = __commonJS({
           }
           const response2 = await model.stream(messages);
           for await (const chunk of response2) {
-            (0, import_core22.throwIfExecutionAborted)(abortSignal);
+            (0, import_core32.throwIfExecutionAborted)(abortSignal);
             switch (chunk.type) {
               case "text-delta": {
                 if (chunk.delta.length === 0) break;
@@ -672,7 +1566,7 @@ var require_dist = __commonJS({
               }
             }
           }
-          (0, import_core22.throwIfExecutionAborted)(abortSignal);
+          (0, import_core32.throwIfExecutionAborted)(abortSignal);
           assertModelFinish({ finishReason, usage });
           if (emit) {
             emitNodeEvent(args.emitEvent, args.nodeId, "text-end", {
@@ -689,12 +1583,12 @@ var require_dist = __commonJS({
             ...providerMetadata !== void 0 ? { providerMetadata } : {},
             ...warnings !== void 0 ? { warnings } : {}
           };
-          (0, import_core22.throwIfExecutionAborted)(abortSignal);
+          (0, import_core32.throwIfExecutionAborted)(abortSignal);
           endTrace(traceSpan, result2);
           return result2;
         }
         const response = await model.invoke(messages);
-        (0, import_core22.throwIfExecutionAborted)(abortSignal);
+        (0, import_core32.throwIfExecutionAborted)(abortSignal);
         assertModelFinish(response);
         if (response.content) args.onTextChunk?.(response.content);
         if (emit) {
@@ -724,26 +1618,26 @@ var require_dist = __commonJS({
         endTrace(traceSpan, result);
         return result;
       } catch (error) {
-        const failure = abortSignal?.aborted ? (0, import_core22.createExecutionCancelledError)() : error;
+        const failure = abortSignal?.aborted ? (0, import_core32.createExecutionCancelledError)() : error;
         failTrace(traceSpan, failure);
         throw failure;
       }
     }
     var createRuntimeId2 = () => {
       try {
-        return (0, import_node_crypto32.randomUUID)();
+        return (0, import_node_crypto5.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)(
+      const abortSignal = (0, import_core42.combineAbortSignals)(
         ctx.node.abortSignal,
         args.abortSignal,
         args.model.options?.abortSignal
       );
-      (0, import_core32.throwIfExecutionAborted)(abortSignal);
+      (0, import_core42.throwIfExecutionAborted)(abortSignal);
       ctx.node.consumeExecution?.("maxModelPasses");
       try {
         return await runReasonEngine({
@@ -1485,7 +2379,7 @@ var require_dist = __commonJS({
         }
       };
     }
-    var import_errors32 = require("@kortyx/core/errors");
+    var import_errors52 = require("@kortyx/core/errors");
     var tryJsonParse = (value) => {
       try {
         return { ok: true, value: JSON.parse(value) };
@@ -1523,12 +2417,12 @@ var require_dist = __commonJS({
       }
       return text;
     };
-    var createTruncatedStructuredOutputError = (label, cause) => new import_errors32.ValidationError(
+    var createTruncatedStructuredOutputError = (label, cause) => new import_errors52.ValidationError(
       "OUTPUT_TRUNCATED",
       `${label} was truncated before producing valid structured output. The model stopped due to output length. Increase maxOutputTokens or simplify the requested output.`,
       cause
     );
-    var createInvalidStructuredOutputError = (label, cause) => new import_errors32.ValidationError(
+    var createInvalidStructuredOutputError = (label, cause) => new import_errors52.ValidationError(
       "INVALID_MODEL_JSON",
       `${label} did not produce valid structured output. The model returned text instead of the expected JSON payload. Check outputSchema and provider structured-output settings.`,
       cause
@@ -1540,7 +2434,7 @@ var require_dist = __commonJS({
       try {
         return parseWithSchema(args.schema, candidate, args.label);
       } catch (error) {
-        if (!(error instanceof import_errors32.ValidationError)) throw error;
+        if (!(error instanceof import_errors52.ValidationError)) throw error;
         const failure = args.finishReason?.unified === "length" ? createTruncatedStructuredOutputError(args.label, error) : typeof candidate === "string" && !validJson ? createInvalidStructuredOutputError(args.label, error) : error;
         if (failure && typeof failure === "object")
           Object.assign(failure, {
@@ -1560,7 +2454,7 @@ var require_dist = __commonJS({
           if (typeof candidate === "string" && candidate.trim().length > 0) {
             throw createInvalidStructuredOutputError("useReason output");
           }
-          throw new import_errors32.ValidationError(
+          throw new import_errors52.ValidationError(
             "MODEL_OUTPUT_SCHEMA",
             "useReason first pass with interrupt must return a JSON object."
           );
@@ -1569,7 +2463,7 @@ var require_dist = __commonJS({
         let interruptRequired = true;
         if (mode === "optional") {
           if (candidate.decision !== "continue" && candidate.decision !== "interrupt") {
-            throw new import_errors32.ValidationError(
+            throw new import_errors52.ValidationError(
               "MODEL_OUTPUT_SCHEMA",
               'useReason optional interrupt first pass must include decision "continue" or "interrupt".'
             );
@@ -1582,7 +2476,7 @@ var require_dist = __commonJS({
               candidate.interrupt
             ].some((value) => value !== null && value !== void 0);
             if (hasUnexpectedRequest) {
-              throw new import_errors32.ValidationError(
+              throw new import_errors52.ValidationError(
                 "MODEL_OUTPUT_SCHEMA",
                 'useReason optional interrupt first pass with decision "continue" must not include an interrupt request.'
               );
@@ -1616,7 +2510,7 @@ var require_dist = __commonJS({
               "useReason output"
             );
           } catch (error) {
-            if (!(error instanceof import_errors32.ValidationError)) throw error;
+            if (!(error instanceof import_errors52.ValidationError)) throw error;
             if (args.finishReason?.unified === "length") {
               throw createTruncatedStructuredOutputError("useReason output", error);
             }
@@ -1625,7 +2519,7 @@ var require_dist = __commonJS({
         }
         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 import_errors32.ValidationError(
+          throw new import_errors52.ValidationError(
             "MODEL_OUTPUT_SCHEMA",
             "useReason first pass with interrupt requires `draftText` when outputSchema is not provided."
           );
@@ -1811,6 +2705,7 @@ ${tryStringify2(args.response)}`
       const reasoning = sum(left.reasoning, right.reasoning);
       const cacheRead = sum(left.cacheRead, right.cacheRead);
       const cacheWrite = sum(left.cacheWrite, right.cacheWrite);
+      const cacheWrite1h = sum(left.cacheWrite1h, right.cacheWrite1h);
       const merged = {
         ...right.outputIncludesReasoning !== void 0 ? { outputIncludesReasoning: right.outputIncludesReasoning } : {},
         ...right.inputIncludesCacheWrite !== void 0 ? { inputIncludesCacheWrite: right.inputIncludesCacheWrite } : {},
@@ -1822,6 +2717,7 @@ ${tryStringify2(args.response)}`
       if (reasoning !== void 0) merged.reasoning = reasoning;
       if (cacheRead !== void 0) merged.cacheRead = cacheRead;
       if (cacheWrite !== void 0) merged.cacheWrite = cacheWrite;
+      if (cacheWrite1h !== void 0) merged.cacheWrite1h = cacheWrite1h;
       if (raw) merged.raw = raw;
       return merged;
     };
@@ -1858,9 +2754,9 @@ ${tryStringify2(args.response)}`
         streamId: args.opId
       });
     };
-    var import_core42 = require("@kortyx/core");
-    var import_errors42 = require("@kortyx/core/errors");
-    var toToolDefinitions = (tools) => tools.map((tool) => ({
+    var import_core52 = require("@kortyx/core");
+    var import_errors62 = require("@kortyx/core/errors");
+    var toToolDefinitions = (tools2) => tools2.map((tool) => ({
       name: tool.name,
       ...tool.title ? { title: tool.title } : {},
       ...tool.description ? { description: tool.description } : {},
@@ -1877,12 +2773,13 @@ ${tryStringify2(args.response)}`
       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;
+      if (value && typeof value === "object" && !Array.isArray(value) && "toolCallId" in value && "name" in value && "content" in value && typeof value.content === "string") {
+        const result = value;
+        return { ...result, toolCallId: toolCall.id, name: toolCall.name };
       }
       let content;
       try {
-        content = typeof value === "string" ? value : JSON.stringify(value);
+        content = typeof value === "string" ? value : JSON.stringify(value) ?? String(value);
       } catch {
         content = String(value);
       }
@@ -1893,28 +2790,6 @@ ${tryStringify2(args.response)}`
         ...value !== void 0 && value !== null && typeof value === "object" && !Array.isArray(value) ? { structuredContent: value } : {}
       };
     };
-    var closeOwnedTools = async (tools, preserveFailure = false, traceSpan) => {
-      const closeFns = /* @__PURE__ */ new Set();
-      for (const tool of tools) {
-        if (tool.closeAfterUse === false || !tool.close) continue;
-        closeFns.add(tool.close);
-      }
-      try {
-        await Promise.all(
-          [...closeFns].map(async (close) => {
-            await close();
-          })
-        );
-      } catch (error) {
-        if (!preserveFailure) throw error;
-        try {
-          traceSpan?.addEvent?.("useReason.cleanup.failed", {
-            failure: (0, import_errors42.serializeFailure)(error)
-          });
-        } catch {
-        }
-      }
-    };
     var createInitialMessages = (args) => [
       ...typeof args.system === "string" && args.system.length > 0 ? [{ role: "system", content: args.system }] : [],
       { role: "user", content: String(args.input ?? "") }
@@ -1922,7 +2797,7 @@ ${tryStringify2(args.response)}`
     var runReasonToolLoop = async (args) => {
       const { useReasonArgs, id, traceSpan, checkpointKey } = args;
       const ctx = getHookContext();
-      const abortSignal = (0, import_core42.combineAbortSignals)(
+      const abortSignal = (0, import_core52.combineAbortSignals)(
         ctx.node.abortSignal,
         useReasonArgs.abortSignal,
         useReasonArgs.model.options?.abortSignal
@@ -1930,43 +2805,32 @@ ${tryStringify2(args.response)}`
       const saved = ctx.currentNodeState.byKey[checkpointKey];
       const checkpoint = saved?.status === "tool_loop" ? saved : void 0;
       const opId = checkpoint?.opId ?? args.opId;
-      let primaryFailure = false;
-      const tools = useReasonArgs.tools ?? [];
+      const tools2 = useReasonArgs.tools ?? [];
       const toolByName = /* @__PURE__ */ new Map();
-      let validationCompleted = false;
       let separateOutput = 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."
-          );
+      for (const tool of tools2) {
+        if (toolByName.has(tool.name)) {
+          throw new Error(`useReason received duplicate tool name "${tool.name}".`);
         }
-        separateOutput = Boolean(
-          useReasonArgs.model.provider.getModel(useReasonArgs.model.modelId, {
-            ...useReasonArgs.model.options,
-            ...useReasonArgs.reasoning !== void 0 ? { reasoning: useReasonArgs.reasoning } : {},
-            ...useReasonArgs.responseFormat ? { responseFormat: useReasonArgs.responseFormat } : {},
-            providerOptions: resolveProviderOptions(
-              useReasonArgs.model.options?.providerOptions,
-              useReasonArgs.providerOptions
-            ) ?? {}
-          }).requiresSeparateStructuredOutput
+        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, true, traceSpan);
-        }
       }
-      const toolDefinitions = toToolDefinitions(tools);
+      separateOutput = Boolean(
+        useReasonArgs.model.provider.getModel(useReasonArgs.model.modelId, {
+          ...useReasonArgs.model.options,
+          ...useReasonArgs.reasoning !== void 0 ? { reasoning: useReasonArgs.reasoning } : {},
+          ...useReasonArgs.responseFormat ? { responseFormat: useReasonArgs.responseFormat } : {},
+          providerOptions: resolveProviderOptions(
+            useReasonArgs.model.options?.providerOptions,
+            useReasonArgs.providerOptions
+          ) ?? {}
+        }).requiresSeparateStructuredOutput
+      );
+      const toolDefinitions = toToolDefinitions(tools2);
       let finalizing = checkpoint?.finalizing ?? false;
       let completed = false;
       const maxSteps = Math.max(1, useReasonArgs.toolExecution?.maxSteps ?? 3);
@@ -2018,7 +2882,7 @@ ${tryStringify2(args.response)}`
       };
       try {
         for (let stepIndex = pending ? steps.length - 1 : steps.length; stepIndex < maxSteps; stepIndex += 1) {
-          (0, import_core42.throwIfExecutionAborted)(abortSignal);
+          (0, import_core52.throwIfExecutionAborted)(abortSignal);
           traceSpan?.addEvent?.("useReason.tool-step.start", {
             stepIndex,
             toolCount: toolDefinitions.length
@@ -2062,6 +2926,12 @@ ${tryStringify2(args.response)}`
           );
           aggregatedWarnings = mergeWarnings(aggregatedWarnings, step.warnings);
           const toolCalls = step.toolCalls ?? [];
+          const ids = /* @__PURE__ */ new Set();
+          for (const call of toolCalls) {
+            if (!call.id || ids.has(call.id) || !reused && allToolCalls.some((prior) => prior.id === call.id))
+              throw new Error("Model returned duplicate or empty tool call IDs.");
+            ids.add(call.id);
+          }
           const toolResults = reused ? steps[stepIndex]?.toolResults ?? [] : [];
           if (!reused)
             steps.push({
@@ -2130,9 +3000,15 @@ ${tryStringify2(args.response)}`
           pending = step;
           save();
           for (const toolCall of toolCalls) {
-            if (toolResults.some((result2) => result2.toolCallId === toolCall.id))
+            if (toolResults.some((result2) => result2.toolCallId === toolCall.id)) {
+              await replayToolObservations(
+                steps[stepIndex]?.toolObservations?.filter(
+                  (observation) => observation.toolCallId === `${opId}:${toolCall.id}`
+                ) ?? []
+              );
               continue;
-            (0, import_core42.throwIfExecutionAborted)(abortSignal);
+            }
+            (0, import_core52.throwIfExecutionAborted)(abortSignal);
             const tool = toolByName.get(toolCall.name);
             if (!tool) {
               throw new Error(
@@ -2149,11 +3025,6 @@ ${tryStringify2(args.response)}`
               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,
@@ -2162,6 +3033,17 @@ ${tryStringify2(args.response)}`
               });
             }
             if (shouldApproveTool && !approvedCalls.includes(toolCall.id)) {
+              await observeToolFact(
+                {
+                  version: 1,
+                  name: tool.name,
+                  toolCallId: `${opId}:${toolCall.id}`,
+                  attemptId: `${opId}:${toolCall.id}:approval`,
+                  callingMode: "model",
+                  executed: false
+                },
+                "waiting"
+              );
               const approval = await awaitInterruptInternal({
                 id: `tool:${toolCall.id}`,
                 request: {
@@ -2180,6 +3062,22 @@ ${tryStringify2(args.response)}`
               });
               const approved = Array.isArray(approval) ? approval.includes("approve") : approval === "approve";
               if (!approved) {
+                const deniedObservation = {
+                  version: 1,
+                  name: tool.name,
+                  toolCallId: `${opId}:${toolCall.id}`,
+                  attemptId: `${opId}:${toolCall.id}:approval`,
+                  callingMode: "model",
+                  executed: false,
+                  outcome: "denied",
+                  denialCode: "APPROVAL_DENIED"
+                };
+                await observeToolFact(deniedObservation);
+                const entry = steps[stepIndex];
+                if (entry) {
+                  entry.toolObservations ??= [];
+                  entry.toolObservations.push(deniedObservation);
+                }
                 const denied = {
                   toolCallId: toolCall.id,
                   name: tool.name,
@@ -2210,13 +3108,24 @@ ${tryStringify2(args.response)}`
               save();
             }
             try {
-              (0, import_core42.throwIfExecutionAborted)(abortSignal);
-              ctx.node.consumeExecution?.("maxToolCalls");
-              const rawResult = await tool.execute(toolCall.input, {
-                toolCallId: toolCall.id,
-                ...abortSignal ? { abortSignal } : {}
+              (0, import_core52.throwIfExecutionAborted)(abortSignal);
+              const rawResult = await executeObservedTool({
+                tool,
+                input: toolCall.input,
+                toolCallId: `${opId}:${toolCall.id}`,
+                providerToolCallId: toolCall.id,
+                callingMode: "model",
+                abortSignal,
+                onObservation: (observation) => {
+                  const entry = steps[stepIndex];
+                  if (entry) {
+                    entry.toolObservations ??= [];
+                    entry.toolObservations.push(observation);
+                    save();
+                  }
+                }
               });
-              (0, import_core42.throwIfExecutionAborted)(abortSignal);
+              (0, import_core52.throwIfExecutionAborted)(abortSignal);
               const result2 = normalizeToolResult(toolCall, rawResult);
               toolResults.push(result2);
               allToolResults.push(result2);
@@ -2229,20 +3138,14 @@ ${tryStringify2(args.response)}`
                   ...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_errors42.isControlFlowError)(error)) throw error;
+              (0, import_core52.throwIfExecutionAborted)(abortSignal);
+              if ((0, import_errors62.isControlFlowError)(error)) throw error;
               const result2 = {
                 toolCallId: toolCall.id,
                 name: tool.name,
-                content: (0, import_errors42.serializeFailure)(error).message,
-                failure: (0, import_errors42.serializeFailure)(error),
+                content: (0, import_errors62.serializeFailure)(error).message,
+                failure: (0, import_errors62.serializeFailure)(error),
                 isError: true
               };
               toolResults.push(result2);
@@ -2255,13 +3158,6 @@ ${tryStringify2(args.response)}`
                   failure: result2.failure
                 });
               }
-              traceSpan?.addEvent?.("useReason.tool-call.error", {
-                stepIndex,
-                tool: tool.name,
-                toolCallId: toolCall.id,
-                message: result2.content,
-                failure: result2.failure
-              });
             }
             const completed2 = toolResults.at(-1);
             if (completed2)
@@ -2334,7 +3230,6 @@ ${tryStringify2(args.response)}`
         ctx.stateDirty = true;
         return result;
       } catch (error) {
-        primaryFailure = true;
         try {
           traceSpan?.fail?.(error, {
             attributes: {
@@ -2345,8 +3240,6 @@ ${tryStringify2(args.response)}`
         } catch {
         }
         throw error;
-      } finally {
-        await closeOwnedTools(tools, primaryFailure, traceSpan);
       }
     };
     var shouldStreamReasonStructured = (args) => (args.emit ?? true) && shouldStreamStructured(args.structured);
@@ -2360,15 +3253,15 @@ ${tryStringify2(args.response)}`
         "useReason does not support reasoning.includeThoughts with structured output, interrupt mode, or JSON responseFormat. Disable includeThoughts for this call."
       );
     };
-    async function useReason(args) {
+    async function runReason(args) {
       assertReasoningThoughtsCompatibility(args);
       const ctx = getHookContext();
-      const abortSignal = (0, import_core52.combineAbortSignals)(
+      const abortSignal = (0, import_core62.combineAbortSignals)(
         ctx.node.abortSignal,
         args.abortSignal,
         args.model.options?.abortSignal
       );
-      (0, import_core52.throwIfExecutionAborted)(abortSignal);
+      (0, import_core62.throwIfExecutionAborted)(abortSignal);
       const allowValidatedToolOutput = Boolean(
         args.outputSchema && !(args.responseFormat ?? args.model.options?.responseFormat)
       );
@@ -2390,287 +3283,304 @@ ${tryStringify2(args.response)}`
       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,
-          allowValidatedToolOutput,
-          checkpointKey,
-          initialWarnings: inferred.warnings,
-          ...id ? { id } : {},
-          opId,
-          ...traceSpan ? { traceSpan } : {}
-        });
+      if (existingCompleted) {
+        await replayToolObservations(
+          existingCompleted.result.steps?.flatMap(
+            (step) => step.toolObservations ?? []
+          ) ?? []
+        );
+        return existingCompleted.result;
       }
-      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)
+      const existingCheckpoint = readReasonCheckpoint(
+        ctx.currentNodeState.byKey[checkpointKey]
       );
-      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 = inferred.warnings;
-      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: createStructuredOutputStreamer(args, id, opId)
-            } : {}
+      const reasonMeta = typeof id === "string" ? { id, opId } : { opId };
+      return withSafeTraceSpan2(
+        getReasonTraceAdapter(),
+        {
+          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)
           },
-          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 } : {},
-            ...first.usage ? { usage: first.usage } : {},
-            ...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 } : {},
-              ...first.usage ? { usage: first.usage } : {},
-              label: "useReason output"
+          telemetry: {
+            ...args.telemetry ?? {},
+            input: args.telemetry?.input ?? args.input
+          }
+        },
+        async (traceSpan) => {
+          if (args.tools?.length) {
+            return runReasonToolLoop({
+              useReasonArgs: args,
+              allowValidatedToolOutput,
+              checkpointKey,
+              initialWarnings: inferred.warnings,
+              ...id ? { id } : {},
+              opId,
+              ...traceSpan ? { traceSpan } : {}
             });
           }
-          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."
+          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)
           );
-        }
-        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
+          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 = inferred.warnings;
+          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: createStructuredOutputStreamer(args, id, 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 } : {},
+                ...first.usage ? { usage: first.usage } : {},
+                ...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 } : {},
+                  ...first.usage ? { usage: first.usage } : {},
+                  label: "useReason output"
+                });
+              }
+              finalOutput = firstOutput;
+            }
           }
-        });
-        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,
-            ...inferred.responseFormat ? { responseFormat: inferred.responseFormat } : {},
-            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({
+          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,
+                ...inferred.responseFormat ? { responseFormat: inferred.responseFormat } : {},
+                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 } : {},
+                ...aggregatedUsage ? { usage: aggregatedUsage } : {},
+                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,
-            schema: args.outputSchema,
-            ...second.finishReason ? { finishReason: second.finishReason } : {},
-            ...aggregatedUsage ? { usage: aggregatedUsage } : {},
-            label: "useReason output"
+            ...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;
         }
+      );
+    }
+    async function useReason(args) {
+      try {
+        return await runReason(args);
+      } finally {
+        await closeOwnedTools(args.tools ?? []);
       }
-      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);
@@ -2725,8 +3635,8 @@ ${tryStringify2(args.response)}`
       };
       return [getValue(), setValue];
     }
-    var import_core62 = require("@kortyx/core");
-    var import_errors52 = require("@kortyx/core/errors");
+    var import_core7 = require("@kortyx/core");
+    var import_errors7 = require("@kortyx/core/errors");
     var ParallelChildWaiting = class extends Error {
       name = "ParallelChildWaiting";
     };
@@ -2740,14 +3650,14 @@ ${tryStringify2(args.response)}`
         );
         this.results = results;
         this.name = "ParallelError";
-        this.failure = (0, import_errors52.serializeFailure)({
+        this.failure = (0, import_errors7.serializeFailure)({
           version: 1,
           code: this.code,
           category: "workflow",
           message: this.message,
           retryable: null,
           results: results.map(
-            (result) => result.status === "fulfilled" ? { status: "fulfilled" } : { status: "rejected", failure: (0, import_errors52.serializeFailure)(result.reason) }
+            (result) => result.status === "fulfilled" ? { status: "fulfilled" } : { status: "rejected", failure: (0, import_errors7.serializeFailure)(result.reason) }
           )
         });
       }
@@ -2755,7 +3665,7 @@ ${tryStringify2(args.response)}`
       code = "PARALLEL_FAILED";
       failure;
       toJSON() {
-        return (0, import_errors52.serializeFailure)(this);
+        return (0, import_errors7.serializeFailure)(this);
       }
     };
     function registerWorkflowTask(id) {
@@ -2851,13 +3761,13 @@ ${tryStringify2(args.response)}`
             );
           }
           if (ready[0]?.status === "rejected") throw ready[0].reason;
-          (0, import_core62.throwIfExecutionAborted)(ctx.node.abortSignal);
+          (0, import_core7.throwIfExecutionAborted)(ctx.node.abortSignal);
           if (ctx.workflowControlError) throw ctx.workflowControlError;
           const rejected = outcomes.filter(
             (outcome) => outcome.status === "rejected"
           );
           const control = rejected.find(
-            (outcome) => (0, import_core62.isExecutionCancelled)(outcome.reason) || (0, import_core62.isExecutionLimitReached)(outcome.reason)
+            (outcome) => (0, import_core7.isExecutionCancelled)(outcome.reason) || (0, import_core7.isExecutionLimitReached)(outcome.reason)
           );
           if (control) {
             ctx.workflowControlError = control.reason;
@@ -2892,50 +3802,13 @@ ${tryStringify2(args.response)}`
       });
       return promise;
     }
-    var import_node_crypto5 = require("crypto");
-    var import_core7 = require("@kortyx/core");
-    var import_errors62 = require("@kortyx/core/errors");
-    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 import_errors62.KortyxError {
+    var import_node_crypto6 = require("crypto");
+    var import_core8 = require("@kortyx/core");
+    var import_errors8 = require("@kortyx/core/errors");
+    var WorkflowCallError = class extends import_errors8.KortyxError {
       constructor(workflow, message, cause, failure) {
-        const detail = (0, import_errors62.serializeFailure)(
-          failure ?? cause ?? new import_errors62.WorkflowContractError(message)
+        const detail = (0, import_errors8.serializeFailure)(
+          failure ?? cause ?? new import_errors8.WorkflowContractError(message)
         );
         super(detail.code, `Workflow '${workflow}': ${message}`, {
           ...detail,
@@ -2956,12 +3829,12 @@ ${tryStringify2(args.response)}`
         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 import_errors62.WorkflowContractError(
+          throw new import_errors8.WorkflowContractError(
             "Workflow input and output must be JSON serializable."
           );
         }
         if (!Array.isArray(v) && Object.getPrototypeOf(v) !== Object.prototype) {
-          throw new import_errors62.WorkflowContractError(
+          throw new import_errors8.WorkflowContractError(
             "Workflow input and output must contain plain JSON objects."
           );
         }
@@ -2982,7 +3855,7 @@ ${tryStringify2(args.response)}`
         useWorkflow: (args) => {
           const workflow = workflows[args.workflow];
           if (!workflow || workflow.id !== args.workflow)
-            throw new import_errors62.WorkflowContractError(
+            throw new import_errors8.WorkflowContractError(
               "Workflow registry keys must match definition ids."
             );
           return useWorkflow({ ...args, workflow });
@@ -2996,7 +3869,7 @@ ${tryStringify2(args.response)}`
         if (task.group) await task.group.ready;
         return await runWorkflowCall(args, task);
       } catch (error) {
-        if ((0, import_core7.isExecutionCancelled)(error) || (0, import_core7.isExecutionLimitReached)(error))
+        if ((0, import_core8.isExecutionCancelled)(error) || (0, import_core8.isExecutionLimitReached)(error))
           getHookContext().workflowControlError = error;
         throw error;
       } finally {
@@ -3005,26 +3878,26 @@ ${tryStringify2(args.response)}`
     }
     async function runWorkflowCall(args, task) {
       const ctx = getHookContext();
-      (0, import_core7.throwIfExecutionAborted)(ctx.node.abortSignal);
+      (0, import_core8.throwIfExecutionAborted)(ctx.node.abortSignal);
       const service = ctx.node.callWorkflow;
       if (!service)
-        throw new import_errors62.WorkflowContractError(
+        throw new import_errors8.WorkflowContractError(
           "useWorkflow requires an agent workflow registry."
         );
       if (!args.id.trim())
-        throw new import_errors62.WorkflowContractError(
+        throw new import_errors8.WorkflowContractError(
           "useWorkflow requires a stable, nonempty id."
         );
       if (ctx.workflowCallActive && !task.group)
-        throw new import_errors62.WorkflowContractError(
+        throw new import_errors8.WorkflowContractError(
           "Concurrent workflow calls require parallel([...]); otherwise await each call."
         );
       if (ctx.workflowCallIds.has(args.id))
-        throw new import_errors62.WorkflowContractError(
+        throw new import_errors8.WorkflowContractError(
           `Duplicate workflow call id '${args.id}' in one node activation.`
         );
       if (ctx.workflowCallIds.size >= 64)
-        throw new import_errors62.WorkflowContractError(
+        throw new import_errors8.WorkflowContractError(
           "A node may call at most 64 child workflows per activation."
         );
       ctx.workflowCallIds.add(args.id);
@@ -3051,7 +3924,7 @@ ${tryStringify2(args.response)}`
       if (!record) ctx.node.consumeExecution?.("maxChildInvocations");
       record ??= {
         fingerprint,
-        invocationId: (0, import_node_crypto5.randomUUID)(),
+        invocationId: (0, import_node_crypto6.randomUUID)(),
         status: "running",
         interrupts: [],
         ...task.group ? { parallelKey: task.group.key } : {}
@@ -3061,7 +3934,7 @@ ${tryStringify2(args.response)}`
       if (!task.group) ctx.workflowCallActive = true;
       const telemetry = ctx.node.workflowCallTelemetry;
       const activationKey = "__useWorkflowActivation";
-      ctx.currentNodeState.byKey[activationKey] ??= (0, import_node_crypto5.randomUUID)();
+      ctx.currentNodeState.byKey[activationKey] ??= (0, import_node_crypto6.randomUUID)();
       const callerNodeExecutionId = ctx.currentNodeState.byKey[activationKey];
       const metadata2 = {
         invocationId: record.invocationId,
@@ -3105,7 +3978,7 @@ ${tryStringify2(args.response)}`
             workflow,
             record.error ?? "child failed",
             void 0,
-            record.failure ?? (0, import_errors62.serializeFailure)(void 0)
+            record.failure ?? (0, import_errors8.serializeFailure)(void 0)
           );
         if (task.group && record.status === "interrupted" && record.interrupts.at(-1)?.response === void 0)
           throw new ParallelChildWaiting();
@@ -3129,9 +4002,9 @@ ${tryStringify2(args.response)}`
           } catch (error) {
             const child = error;
             recordUsage(child?.__kortyxChildUsage);
-            (0, import_core7.throwIfExecutionAborted)(ctx.node.abortSignal);
-            if ((0, import_core7.isExecutionCancelled)(error)) throw error;
-            if ((0, import_core7.isExecutionLimitReached)(error)) {
+            (0, import_core8.throwIfExecutionAborted)(ctx.node.abortSignal);
+            if ((0, import_core8.isExecutionCancelled)(error)) throw error;
+            if ((0, import_core8.isExecutionLimitReached)(error)) {
               if (child?.__kortyxChildSnapshot)
                 record.snapshot = child.__kortyxChildSnapshot;
               report("suspended", {
@@ -3141,7 +4014,7 @@ ${tryStringify2(args.response)}`
               throw error;
             }
             record.status = "failed";
-            record.failure = (0, import_errors62.serializeFailure)(error);
+            record.failure = (0, import_errors8.serializeFailure)(error);
             record.error = record.failure.message;
             report("failed", { error: "Child workflow failed" });
             throw new WorkflowCallError(
@@ -3151,12 +4024,15 @@ ${tryStringify2(args.response)}`
               record.failure
             );
           }
-          (0, import_core7.throwIfExecutionAborted)(ctx.node.abortSignal);
+          (0, import_core8.throwIfExecutionAborted)(ctx.node.abortSignal);
           recordUsage(outcome.usage);
           if (outcome.status === "completed") {
             record.data = outcome.data;
             workflowCallFingerprint(record.data);
             record.status = "completed";
+            record.toolObservations = outcome.toolObservations ?? [];
+            for (const observation of record.toolObservations)
+              rememberToolObservation(observation);
             delete record.snapshot;
             report(
               "completed",
@@ -3179,8 +4055,12 @@ ${tryStringify2(args.response)}`
             });
           }
         }
-        if (cached)
+        if (cached) {
           report("reused", workflowCallContent(telemetry, "output", record.data));
+          if (record.restoredToolBranch !== telemetry?.correlation?.branchId)
+            await replayToolObservations(record.toolObservations ?? [], true);
+          delete record.restoredToolBranch;
+        }
         const data = record.data ?? {};
         return {
           data: JSON.parse(JSON.stringify(data))
@@ -3417,6 +4297,7 @@ var ExecutionRequestError = class extends import_errors2.KortyxError {
 var import_node_stream = require("stream");
 var import_core2 = require("@kortyx/core");
 var import_errors4 = require("@kortyx/core/errors");
+var import_internal = __toESM(require_internal());
 var import_runtime = require("@kortyx/runtime");
 var import_langgraph = require("@langchain/langgraph");
 
@@ -3894,7 +4775,8 @@ async function orchestrateGraphStream({
   onOutcome,
   selectWorkflow,
   knownWorkflowIds,
-  frameworkAdapter
+  frameworkAdapter,
+  executionLeaseRelease
 }) {
   const out = new import_node_stream.PassThrough({ objectMode: true });
   const write = (chunk) => {
@@ -3912,11 +4794,13 @@ async function orchestrateGraphStream({
   let currentGraph = graph;
   let currentState = state;
   let finished = false;
+  const leaseAbort = new AbortController();
+  let releaseLease = executionLeaseRelease;
   const response = createResponseLifecycle({
     enabled: emitOutput,
     restored: initialConfig.responseCompleted === true,
     requestSignal,
-    executionSignal,
+    executionSignal: executionSignal ? AbortSignal.any([executionSignal, leaseAbort.signal]) : leaseAbort.signal,
     onClosed: () => {
       out.write({ type: "done" });
       out.end();
@@ -3988,7 +4872,9 @@ async function orchestrateGraphStream({
   let structuredSeq = 0;
   const debugEnabled = Boolean(config?.features?.tracing);
   const traceAdapter = getTraceAdapter(config);
-  const contextMeta = isRecord3(config.context) ? config.context : {};
+  const contextMeta = (0, import_internal.safeTelemetryMetadata)(
+    isRecord3(config.context) ? { userId: config.context.userId, tenantId: config.context.tenantId } : {}
+  );
   const telemetryConfig = isRecord3(config.telemetry) ? config.telemetry : {};
   const emitResumeFailure = (resumeError) => {
     const interruptId = typeof config.telemetryInterruptId === "string" ? config.telemetryInterruptId : void 0;
@@ -4024,8 +4910,13 @@ async function orchestrateGraphStream({
         ...isRecord3(telemetryConfig.metadata) ? telemetryConfig.metadata : {},
         ...contextMeta
       },
-      tags: Array.isArray(telemetryConfig.tags) ? telemetryConfig.tags : void 0,
-      captureContent: telemetryConfig.captureContent,
+      tags: Array.isArray(telemetryConfig.tags) ? telemetryConfig.tags.filter(
+        (tag) => typeof tag === "string"
+      ) : void 0,
+      captureContent: typeof telemetryConfig.captureContent === "boolean" ? telemetryConfig.captureContent : isRecord3(telemetryConfig.captureContent) ? {
+        ...typeof telemetryConfig.captureContent.input === "boolean" ? { input: telemetryConfig.captureContent.input } : {},
+        ...typeof telemetryConfig.captureContent.output === "boolean" ? { output: telemetryConfig.captureContent.output } : {}
+      } : void 0,
       input: typeof state.input === "string" ? state.input : JSON.stringify(state.input)
     }
   };
@@ -4781,24 +5672,36 @@ async function orchestrateGraphStream({
     }
   };
   const emitTraceChunk = () => {
-    const traceContext = traceAdapter?.getActiveContext?.();
-    if (!traceContext) return;
-    write({
-      type: "trace",
-      traceId: traceContext.traceId,
-      spanId: traceContext.spanId,
-      runId,
-      rootSpanName: "kortyx.run"
-    });
+    try {
+      const traceContext = traceAdapter?.getActiveContext?.();
+      if (!traceContext) return;
+      write({
+        type: "trace",
+        traceId: traceContext.traceId,
+        spanId: traceContext.spanId,
+        runId,
+        rootSpanName: "kortyx.run"
+      });
+    } catch {
+    }
   };
-  const fallbackRunSpan = traceAdapter?.withSpan ? void 0 : traceAdapter?.startSpan?.(runSpanArgs);
+  let fallbackRunSpan;
   if (!traceAdapter?.withSpan) {
+    fallbackRunSpan = (0, import_internal.safeStartSpan)(traceAdapter, runSpanArgs);
     emitTraceChunk();
   }
-  const runPromise = traceAdapter?.withSpan ? traceAdapter.withSpan(runSpanArgs, (runTraceSpan) => {
+  const startRun = () => traceAdapter?.withSpan ? (0, import_internal.withSafeTraceSpan)(traceAdapter, runSpanArgs, async (runTraceSpan) => {
     emitTraceChunk();
     return runLoop(runTraceSpan);
-  }) : runLoop(fallbackRunSpan ?? {});
+  }) : runLoop(fallbackRunSpan);
+  const runPromise = frameworkAdapter?.acquireRunLease && !releaseLease ? frameworkAdapter.acquireRunLease({
+    runId,
+    ...sessionId ? { sessionId } : {},
+    onLost: (cause) => leaseAbort.abort(cause)
+  }).then((release) => {
+    releaseLease = release;
+    return startRun();
+  }) : startRun();
   const finishCancelled = async () => {
     emitTelemetryEvent({
       config,
@@ -4962,7 +5865,12 @@ async function orchestrateGraphStream({
     write({ type: "done" });
     finished = true;
     out.end();
-  }).finally(() => {
+  }).finally(async () => {
+    try {
+      await releaseLease?.();
+    } catch (error) {
+      console.error("[execution:releaseLease]", (0, import_errors4.serializeFailure)(error));
+    }
     response.dispose();
     onOutcome?.({
       state: outcomeState,
@@ -5023,7 +5931,7 @@ async function tryPrepareResumeStream({
   if (!meta) return null;
   const store = frameworkAdapter?.pendingRequests;
   if (!store) return null;
-  const pending = await store.get(meta.token);
+  let pending = await store.get(meta.token);
   if (!pending || pending.requestId !== meta.requestId) {
     throw new ExecutionRequestError(
       "INVALID_RESUME",
@@ -5053,34 +5961,48 @@ async function tryPrepareResumeStream({
       yield { type: "done" };
     })();
   }
-  if (store.take && !await store.take(meta.token))
-    throw new ExecutionRequestError(
-      "INVALID_RESUME",
-      "Interrupt has already been resumed or cancelled."
-    );
-  if (meta.cancel) {
-    await store.delete(pending.token);
-    emitTelemetryEvent({
-      config,
-      type: "interrupt.cancelled",
-      correlation: {
-        runId: pending.runId,
-        sessionId,
-        workflowId: pending.workflow,
-        nodeId: pending.node
-      },
-      payload: {
-        interruptId: pending.requestId,
-        reason: "cancelled_by_client"
-      },
-      flush: true
-    });
-    onOutcome?.({ state: pending.state, cancelled: true });
-    return (async function* () {
-      yield { type: "done" };
-    })();
-  }
+  const leaseAbort = new AbortController();
+  let releaseLease;
+  let consumed = false;
   try {
+    releaseLease = await frameworkAdapter?.acquireRunLease?.({
+      runId: pending.runId,
+      sessionId,
+      onLost: (cause) => leaseAbort.abort(cause)
+    });
+    leaseAbort.signal.throwIfAborted();
+    if (store.take) {
+      const taken = await store.take(meta.token);
+      if (!taken)
+        throw new ExecutionRequestError(
+          "INVALID_RESUME",
+          "Interrupt has already been resumed or cancelled."
+        );
+      pending = taken;
+    }
+    consumed = true;
+    if (meta.cancel) {
+      await store.delete(pending.token);
+      emitTelemetryEvent({
+        config,
+        type: "interrupt.cancelled",
+        correlation: {
+          runId: pending.runId,
+          sessionId,
+          workflowId: pending.workflow,
+          nodeId: pending.node
+        },
+        payload: {
+          interruptId: pending.requestId,
+          reason: "cancelled_by_client"
+        },
+        flush: true
+      });
+      onOutcome?.({ state: pending.state, cancelled: true });
+      return (async function* () {
+        yield { type: "done" };
+      })();
+    }
     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 : {};
@@ -5135,6 +6057,7 @@ async function tryPrepareResumeStream({
           ...resumeStatePatch
         };
     }
+    leaseAbort.signal.throwIfAborted();
     if (pending.graphSnapshot && frameworkAdapter)
       await (0, import_runtime2.restoreGraphSnapshot)(
         frameworkAdapter.checkpointer,
@@ -5184,9 +6107,11 @@ async function tryPrepareResumeStream({
       },
       flush: true
     });
+    const continuedSignal = pending.responseCompleted && emitOutput === false ? abortSignal : executionSignal;
     const args = {
       abortSignal,
-      executionSignal: pending.responseCompleted && emitOutput === false ? abortSignal : executionSignal,
+      executionSignal: continuedSignal ? AbortSignal.any([continuedSignal, leaseAbort.signal]) : leaseAbort.signal,
+      executionLeaseRelease: releaseLease,
       onExecution,
       emitOutput,
       onOutcome,
@@ -5207,11 +6132,15 @@ async function tryPrepareResumeStream({
       knownWorkflowIds,
       frameworkAdapter
     };
+    leaseAbort.signal.throwIfAborted();
     const stream = await orchestrateGraphStream(args);
+    releaseLease = void 0;
     return stream;
   } catch (error) {
-    await store.save(pending);
+    if (consumed && !leaseAbort.signal.aborted) await store.save(pending);
     throw error;
+  } finally {
+    await releaseLease?.();
   }
 }
 
@@ -5527,6 +6456,7 @@ var import_hooks = __toESM(require_dist());
 function restoreWorkflowCallBranch(requests, telemetry, sourceRunId) {
   const branchId = (0, import_node_crypto3.randomUUID)();
   const emitted = /* @__PURE__ */ new Set();
+  const toolEvidence = /* @__PURE__ */ new Set();
   for (const request of requests) {
     if (request.state)
       request.state.config = {
@@ -5564,6 +6494,52 @@ function restoreWorkflowCallBranch(requests, telemetry, sourceRunId) {
                 status: record.status
               }
             );
+            if (record.status === "completed" && Array.isArray(record.toolObservations)) {
+              if (telemetry?.reporter && telemetry.environment && telemetry.service)
+                record.restoredToolBranch = branchId;
+              for (const original of record.toolObservations) {
+                const key = JSON.stringify([
+                  original.invocationId,
+                  original.toolCallId,
+                  original.attemptId
+                ]);
+                if (toolEvidence.has(key)) continue;
+                toolEvidence.add(key);
+                const payload = {
+                  ...original,
+                  runId: request.runId,
+                  branchId,
+                  attemptId: (0, import_node_crypto3.randomUUID)(),
+                  executed: false,
+                  durationMs: void 0,
+                  observationKind: "reused",
+                  source: original.source ?? {
+                    runId: original.runId ?? sourceRunId,
+                    invocationId: original.invocationId,
+                    branchId: original.branchId,
+                    toolCallId: original.toolCallId,
+                    attemptId: original.attemptId
+                  }
+                };
+                (0, import_hooks.emitWorkflowCall)(
+                  telemetry ? {
+                    ...telemetry,
+                    correlation: {
+                      runId: request.runId,
+                      sessionId: request.sessionId,
+                      workflowId: original.workflowId ?? request.workflow,
+                      nodeId: original.nodeId,
+                      workflowRevisionId: original.workflowRevisionId,
+                      invocationId: original.invocationId,
+                      parentInvocationId: original.parentInvocationId,
+                      branchId
+                    }
+                  } : void 0,
+                  "tool.reused",
+                  payload
+                );
+              }
+            }
           }
         }
       }
@@ -5907,30 +6883,38 @@ function createAgent(args) {
   const getCheckpoint = (id) => resolvedFrameworkAdapter.sessionCheckpoints.get(id);
   const rollbackTo = async (id) => {
     const target = await resolvedFrameworkAdapter.sessionCheckpoints.get(id);
-    const result = await resolvedFrameworkAdapter.sessionCheckpoints.rollbackTo(id);
-    const activePendingRequests = await Promise.all(
-      result.activePendingRequests.map(
-        (request) => hydratePendingGraphCheckpoint(resolvedFrameworkAdapter, request)
-      )
-    );
-    restoreWorkflowCallBranch(
-      activePendingRequests,
-      telemetry,
-      target?.runId ?? "unknown"
-    );
-    await Promise.all(
-      activePendingRequests.map(
-        (request) => clearPendingGraphWrites(resolvedFrameworkAdapter, request)
-      )
+    const sourceRunId = target?.runId ?? "unknown";
+    const managed = resolvedFrameworkAdapter.sessionCheckpoints.managesPendingRequests;
+    const result = await resolvedFrameworkAdapter.sessionCheckpoints.rollbackTo(
+      id,
+      managed ? {
+        preparePendingRequests: (requests) => restoreWorkflowCallBranch(requests, telemetry, sourceRunId)
+      } : void 0
     );
-    await Promise.all([
-      ...result.invalidatedInterruptTokens.map(
-        (token) => resolvedFrameworkAdapter.pendingRequests.delete(token)
-      ),
-      ...activePendingRequests.map(
-        (request) => resolvedFrameworkAdapter.pendingRequests.save(request)
-      )
-    ]);
+    let activePendingRequests;
+    if (managed) {
+      activePendingRequests = result.activePendingRequests;
+    } else {
+      activePendingRequests = await Promise.all(
+        result.activePendingRequests.map(
+          (request) => hydratePendingGraphCheckpoint(resolvedFrameworkAdapter, request)
+        )
+      );
+      restoreWorkflowCallBranch(activePendingRequests, telemetry, sourceRunId);
+      await Promise.all(
+        activePendingRequests.map(
+          (request) => clearPendingGraphWrites(resolvedFrameworkAdapter, request)
+        )
+      );
+      await Promise.all([
+        ...result.invalidatedInterruptTokens.map(
+          (token) => resolvedFrameworkAdapter.pendingRequests.delete(token)
+        ),
+        ...activePendingRequests.map(
+          (request) => resolvedFrameworkAdapter.pendingRequests.save(request)
+        )
+      ]);
+    }
     if (target) {
       emitTelemetryEvent({
         config: { ...telemetry ? { telemetry } : {} },
@@ -5950,30 +6934,36 @@ function createAgent(args) {
   };
   const fork = async (id, options) => {
     const source = await resolvedFrameworkAdapter.sessionCheckpoints.get(id);
+    const sourceRunId = source?.runId ?? "unknown";
+    const managed = resolvedFrameworkAdapter.sessionCheckpoints.managesPendingRequests;
     const result = await resolvedFrameworkAdapter.sessionCheckpoints.fork(
       id,
-      options
-    );
-    const activePendingRequests = await Promise.all(
-      result.checkpoint.activePendingRequests.map(
-        (request) => hydratePendingGraphCheckpoint(resolvedFrameworkAdapter, request)
-      )
-    );
-    restoreWorkflowCallBranch(
-      activePendingRequests,
-      telemetry,
-      source?.runId ?? "unknown"
-    );
-    await Promise.all(
-      activePendingRequests.map(
-        (request) => clearPendingGraphWrites(resolvedFrameworkAdapter, request)
-      )
-    );
-    await Promise.all(
-      activePendingRequests.map(
-        (request) => resolvedFrameworkAdapter.pendingRequests.save(request)
-      )
+      managed ? {
+        ...options,
+        preparePendingRequests: (requests) => restoreWorkflowCallBranch(requests, telemetry, sourceRunId)
+      } : options
     );
+    let activePendingRequests;
+    if (managed) {
+      activePendingRequests = result.checkpoint.activePendingRequests;
+    } else {
+      activePendingRequests = await Promise.all(
+        result.checkpoint.activePendingRequests.map(
+          (request) => hydratePendingGraphCheckpoint(resolvedFrameworkAdapter, request)
+        )
+      );
+      restoreWorkflowCallBranch(activePendingRequests, telemetry, sourceRunId);
+      await Promise.all(
+        activePendingRequests.map(
+          (request) => clearPendingGraphWrites(resolvedFrameworkAdapter, request)
+        )
+      );
+      await Promise.all(
+        activePendingRequests.map(
+          (request) => resolvedFrameworkAdapter.pendingRequests.save(request)
+        )
+      );
+    }
     emitTelemetryEvent({
       config: { ...telemetry ? { telemetry } : {} },
       type: "session.forked",