@kortyx/agent 0.38.0 → 0.38.1

package/CHANGELOG.md

@@ -2,10 +2,29 @@
 
 ## Unreleased
 
+- Preserve completed tool results and addressed human answers across root and child execution-budget continuations. Continue renews only the saved allowance and does not answer a later review.
+
 - Add bounded, idempotent queued eval execution with shared consumer capacity,
   event replay, explicit cancellation and optional PostgreSQL recovery.
 
 
+## [0.38.1](https://github.com/kortyx-io/kortyx/compare/agent-v0.38.0...agent-v0.38.1) (2026-10-14)
+
+
+### Bug Fixes
+
+* **runtime:** preserve interrupt state across pauses and resume ([#348](https://github.com/kortyx-io/kortyx/issues/348)) ([03b49f2](https://github.com/kortyx-io/kortyx/commit/03b49f2b8b6b44a2852d16fd4fe1b3e199316072))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @kortyx/runtime bumped to 0.24.1
+    * @kortyx/utils bumped to 0.3.8
+  * devDependencies
+    * @kortyx/hooks bumped to 0.34.3
+
 ## [0.38.0](https://github.com/kortyx-io/kortyx/compare/agent-v0.37.1...agent-v0.38.0) (2026-10-13)
 
 

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export { ar as AgentProcessOptions, as as AgentProjectTopologyOptions, at as Cha
 import { C as ChatMessage } from './chat-message-D4EsFcr1.js';
 export { StreamChatFromRouteArgs, streamChatFromRoute } from './browser.js';
 import { GetProviderFn } from '@kortyx/providers';
+import * as _kortyx_runtime from '@kortyx/runtime';
 import { PendingRequestRecord, FrameworkAdapter, WorkflowRegistry, EvalExecutionStore } from '@kortyx/runtime';
 import { StreamChunk } from '@kortyx/stream';
 import { ExecutionBudget, GraphState, WorkflowDefinition, ExecutionLimits } from '@kortyx/core';
@@ -109,6 +110,7 @@ interface CompiledGraphLike {
     execution?: {
         abortSignal?: AbortSignal | undefined;
         budget?: ExecutionBudget | undefined;
+        resumeDelivery?: _kortyx_runtime.ResumeDelivery | undefined;
         completeResponse?: ((options: _kortyx_hooks.CompleteResponseOptions, state: GraphState) => Promise<void>) | undefined;
     };
     config?: Record<string, unknown>;

package/dist/index.js

@@ -1996,7 +1996,7 @@ var require_internal = __commonJS({
     var import_node2 = require("@kortyx/usage-telemetry/node");
     var package_default2 = {
       name: "@kortyx/hooks",
-      version: "0.34.2",
+      version: "0.34.3",
       private: false,
       description: "Lifecycle hooks and extension points for Kortyx.",
       keywords: [
@@ -2632,7 +2632,7 @@ var require_dist2 = __commonJS({
     var import_node2 = require("@kortyx/usage-telemetry/node");
     var package_default2 = {
       name: "@kortyx/hooks",
-      version: "0.34.2",
+      version: "0.34.3",
       private: false,
       description: "Lifecycle hooks and extension points for Kortyx.",
       keywords: [
@@ -5292,6 +5292,36 @@ ${tryStringify2(args.response)}`
     var import_core52 = require("@kortyx/core");
     var import_errors62 = require("@kortyx/core/errors");
     var import_zod52 = require("zod");
+    var record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+    function schemaPath(schema, path) {
+      let current = schema;
+      let label = "";
+      for (const part of path.slice(0, 8)) {
+        if (!record(current)) break;
+        if (typeof part === "number" && Number.isSafeInteger(part) && part >= 0) {
+          if (!record(current.items)) break;
+          current = current.items;
+          label += `[${part}]`;
+        } else if (typeof part === "string" && record(current.properties) && Object.hasOwn(current.properties, part)) {
+          current = current.properties[part];
+          label += `${label ? "." : ""}${part.slice(0, 64)}`;
+        } else break;
+      }
+      return label || "input";
+    }
+    function interruptInputFeedback(error, schema, name, required) {
+      const issues = Array.isArray(error.issues) ? error.issues : [];
+      const problems = issues.slice(0, 5).map((issue2) => {
+        const path = record(issue2) && Array.isArray(issue2.path) ? issue2.path : [];
+        return `- ${schemaPath(schema, path)} must satisfy its declared input schema.`;
+      });
+      return [
+        `Invalid input for ${name}:`,
+        ...problems,
+        ...issues.length > 5 ? ["- Additional input fields are invalid."] : [],
+        required ? "Correct the input and call the tool again. Human input is required before finishing." : "Correct the input and call the tool again, or finish without requesting human input when none is needed."
+      ].join("\n");
+    }
     var toToolDefinitions = (tools2) => tools2.map((tool) => ({
       name: tool.name,
       ...tool.title ? { title: tool.title } : {},
@@ -6018,11 +6048,35 @@ ${tryStringify2(args.response)}`
                 throw new Error(
                   `useReason reached interrupts.maxRequests (${interruptConfig?.maxRequests ?? 1}).`
                 );
-              const request = parseWithSchema(
-                resolved.contract.requestSchema,
-                toolCall.input,
-                `useReason interrupt contract "${resolved.name}" request`
-              );
+              let request;
+              try {
+                request = parseWithSchema(
+                  resolved.contract.requestSchema,
+                  toolCall.input,
+                  `useReason interrupt contract "${resolved.name}" request`
+                );
+              } catch (error) {
+                if (!(error instanceof import_errors62.ValidationError)) throw error;
+                const result3 = {
+                  toolCallId: toolCall.id,
+                  name: toolCall.name,
+                  isError: true,
+                  content: interruptInputFeedback(
+                    error,
+                    interruptDefinitions.find((tool2) => tool2.name === toolCall.name)?.inputSchema,
+                    toolCall.name,
+                    interruptConfig?.mode === "required"
+                  )
+                };
+                toolResults.push(result3);
+                messages2.push({ role: "tool", ...result3 });
+                traceSpan?.addEvent?.("useReason.interrupt.invalid", {
+                  checkpointKey,
+                  contract: resolved.name
+                });
+                save();
+                continue;
+              }
               traceSpan?.addEvent?.("useReason.interrupt.requested", {
                 checkpointKey,
                 contract: resolved.name,
@@ -6956,10 +7010,10 @@ ${tryStringify2(args.response)}`
             throw new Error("Parallel call membership changed during replay.");
           }
           for (const callId of group.record.calls) {
-            const record = callRecord(callId);
-            if (record?.status !== "interrupted") continue;
-            const index = record.interrupts.length - 1;
-            if (record.interrupts[index]?.response !== void 0) continue;
+            const record2 = callRecord(callId);
+            if (record2?.status !== "interrupted") continue;
+            const index = record2.interrupts.length - 1;
+            if (record2.interrupts[index]?.response !== void 0) continue;
             group.record.interrupts.push({ callId, index });
             await bridge(callId, index);
             throw new Error(
@@ -7124,26 +7178,26 @@ ${tryStringify2(args.response)}`
         version: definition?.version ?? null
       });
       const key = `__useWorkflow:${args.id}`;
-      let record = ctx.currentNodeState.byKey[key];
-      if (record && record.parallelKey !== task.group?.key)
+      let record2 = ctx.currentNodeState.byKey[key];
+      if (record2 && record2.parallelKey !== task.group?.key)
         throw new WorkflowCallError(
           workflow,
           "parallel call membership changed during replay"
         );
-      if (record && record.fingerprint !== fingerprint)
+      if (record2 && record2.fingerprint !== fingerprint)
         throw new WorkflowCallError(
           workflow,
           "call input or target changed during replay"
         );
-      if (!record) ctx.node.consumeExecution?.("maxChildInvocations");
-      record ??= {
+      if (!record2) ctx.node.consumeExecution?.("maxChildInvocations");
+      record2 ??= {
         fingerprint,
         invocationId: (0, import_node_crypto62.randomUUID)(),
         status: "running",
         interrupts: [],
         ...task.group ? { parallelKey: task.group.key } : {}
       };
-      ctx.currentNodeState.byKey[key] = record;
+      ctx.currentNodeState.byKey[key] = record2;
       ctx.stateDirty = true;
       if (!task.group) ctx.workflowCallActive = true;
       const telemetry = ctx.node.workflowCallTelemetry;
@@ -7151,7 +7205,7 @@ ${tryStringify2(args.response)}`
       ctx.currentNodeState.byKey[activationKey] ??= (0, import_node_crypto62.randomUUID)();
       const callerNodeExecutionId = ctx.currentNodeState.byKey[activationKey];
       const metadata2 = {
-        invocationId: record.invocationId,
+        invocationId: record2.invocationId,
         parentInvocationId: telemetry?.correlation?.invocationId ?? null,
         branchId: telemetry?.correlation?.branchId ?? telemetry?.correlation?.runId ?? "unknown",
         callId: args.id,
@@ -7161,46 +7215,49 @@ ${tryStringify2(args.response)}`
         targetWorkflowId: workflow,
         targetVersion: definition?.version ?? null
       };
-      record.telemetry = metadata2;
+      record2.telemetry = metadata2;
       const report = (status2, content = {}) => {
-        record.sequence = (record.sequence ?? 0) + 1;
+        record2.sequence = (record2.sequence ?? 0) + 1;
         emitWorkflowCall2(telemetry, `workflow.call.${status2}`, {
           ...metadata2,
-          sequence: record.sequence,
+          sequence: record2.sequence,
           ...content
         });
       };
       const recordUsage = (usage22) => {
         if (!usage22) return;
         accumulateTokenUsage({
-          input: usage22.input - (record.usage?.input ?? 0),
-          output: usage22.output - (record.usage?.output ?? 0),
-          total: usage22.total - (record.usage?.total ?? 0)
+          input: usage22.input - (record2.usage?.input ?? 0),
+          output: usage22.output - (record2.usage?.output ?? 0),
+          total: usage22.total - (record2.usage?.total ?? 0)
         });
-        record.usage = usage22;
+        record2.usage = usage22;
       };
-      const cached = record.status === "completed";
+      const cached = record2.status === "completed";
       try {
-        for (const interruption of task.group ? [] : record.interrupts) {
+        for (const interruption of task.group ? [] : record2.interrupts) {
           interruption.response = await awaitInterruptInternal({
             request: interruption.request,
             ...interruption.request.meta ? { meta: interruption.request.meta } : {}
           });
         }
-        if (record.status === "failed")
+        if (record2.status === "failed")
           throw new WorkflowCallError(
             workflow,
-            record.error ?? "child failed",
+            record2.error ?? "child failed",
             void 0,
-            record.failure ?? (0, import_errors82.serializeFailure)(void 0)
+            record2.failure ?? (0, import_errors82.serializeFailure)(void 0)
           );
-        if (task.group && record.status === "interrupted" && record.interrupts.at(-1)?.response === void 0)
+        if (task.group && record2.status === "interrupted" && record2.interrupts.at(-1)?.response === void 0)
           throw new ParallelChildWaiting();
-        while (record.status !== "completed") {
+        while (record2.status !== "completed") {
           let outcome;
           try {
+            if (Array.isArray(record2.snapshot) && record2.snapshot.length !== 1)
+              throw new import_errors82.WorkflowContractError("Invalid child workflow snapshot.");
+            const snapshot = Array.isArray(record2.snapshot) ? record2.snapshot[0] : record2.snapshot;
             report(
-              record.snapshot ? "resumed" : "started",
+              snapshot ? "resumed" : "started",
               workflowCallContent(telemetry, "input", input)
             );
             outcome = await service({
@@ -7209,9 +7266,9 @@ ${tryStringify2(args.response)}`
               workflow,
               input,
               definition,
-              invocationId: record.invocationId,
-              ...record.snapshot ? { snapshot: record.snapshot } : {},
-              ...record.interrupts.length ? { response: record.interrupts.at(-1)?.response } : {}
+              invocationId: record2.invocationId,
+              ...snapshot ? { snapshot } : {},
+              ...record2.interrupts.length ? { response: record2.interrupts.at(-1)?.response } : {}
             });
           } catch (error) {
             const child = error;
@@ -7220,48 +7277,48 @@ ${tryStringify2(args.response)}`
             if ((0, import_core8.isExecutionCancelled)(error)) throw error;
             if ((0, import_core8.isExecutionLimitReached)(error)) {
               if (child?.__kortyxChildSnapshot)
-                record.snapshot = child.__kortyxChildSnapshot;
+                record2.snapshot = child.__kortyxChildSnapshot;
               report("suspended", {
                 reason: "limit_reached",
                 limit: error.limitReached
               });
               throw error;
             }
-            record.status = "failed";
-            record.failure = (0, import_errors82.serializeFailure)(error);
-            record.error = record.failure.message;
+            record2.status = "failed";
+            record2.failure = (0, import_errors82.serializeFailure)(error);
+            record2.error = record2.failure.message;
             report("failed", { error: "Child workflow failed" });
             throw new WorkflowCallError(
               workflow,
-              record.error,
+              record2.error,
               error,
-              record.failure
+              record2.failure
             );
           }
           (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)
+            record2.data = outcome.data;
+            workflowCallFingerprint(record2.data);
+            record2.status = "completed";
+            record2.toolObservations = outcome.toolObservations ?? [];
+            for (const observation of record2.toolObservations)
               rememberToolObservation(observation);
-            delete record.snapshot;
+            delete record2.snapshot;
             report(
               "completed",
-              workflowCallContent(telemetry, "output", record.data)
+              workflowCallContent(telemetry, "output", record2.data)
             );
           } else {
-            record.status = "interrupted";
-            record.snapshot = outcome.snapshot;
+            record2.status = "interrupted";
+            record2.snapshot = outcome.snapshot;
             report("suspended", {
               leaf: outcome.request.meta?.workflowCall ?? null
             });
             const interruption = {
               request: outcome.request
             };
-            record.interrupts.push(interruption);
+            record2.interrupts.push(interruption);
             if (task.group) throw new ParallelChildWaiting();
             interruption.response = await awaitInterruptInternal({
               request: interruption.request,
@@ -7270,12 +7327,12 @@ ${tryStringify2(args.response)}`
           }
         }
         if (cached) {
-          report("reused", workflowCallContent(telemetry, "output", record.data));
-          if (record.restoredToolBranch !== telemetry?.correlation?.branchId)
-            await replayToolObservations(record.toolObservations ?? [], true);
-          delete record.restoredToolBranch;
+          report("reused", workflowCallContent(telemetry, "output", record2.data));
+          if (record2.restoredToolBranch !== telemetry?.correlation?.branchId)
+            await replayToolObservations(record2.toolObservations ?? [], true);
+          delete record2.restoredToolBranch;
         }
-        const data = record.data ?? {};
+        const data = record2.data ?? {};
         return {
           data: JSON.parse(JSON.stringify(data))
         };
@@ -7368,6 +7425,7 @@ var ChatLifecycleHookError = class extends import_errors.KortyxError {
 // src/interrupt/resume-handler.ts
 var import_core3 = require("@kortyx/core");
 var import_runtime2 = require("@kortyx/runtime");
+var import_utils = require("@kortyx/utils");
 
 // src/execution/types.ts
 var import_errors2 = require("@kortyx/core/errors");
@@ -7848,7 +7906,7 @@ var import_node = require("@kortyx/usage-telemetry/node");
 // package.json
 var package_default = {
   name: "@kortyx/agent",
-  version: "0.38.0",
+  version: "0.38.1",
   private: false,
   description: "Agent composition utilities for Kortyx.",
   keywords: [
@@ -9040,7 +9098,15 @@ async function orchestrateGraphStream({
     if ((0, import_core2.isExecutionLimitReached)(err)) {
       usageLimitReached = true;
       try {
-        const snapshot = frameworkAdapter && await (0, import_runtime.captureGraphSnapshot)(frameworkAdapter.checkpointer, runId);
+        const snapshot = frameworkAdapter && await (0, import_runtime.captureGraphSnapshot)(
+          frameworkAdapter.checkpointer,
+          runId,
+          void 0,
+          {
+            runtimePatch,
+            response: currentGraph.execution?.resumeDelivery
+          }
+        );
         (0, import_core2.throwIfExecutionAborted)(abortSignal);
         if (!snapshot)
           throw new Error(
@@ -9367,12 +9433,13 @@ async function tryPrepareResumeStream({
       }
     } : {};
     if (isLimitPause && pending.graphSnapshot) {
+      pending.graphSnapshot = (0, import_runtime2.prepareSuspensionSnapshot)(pending.graphSnapshot);
       pending.graphSnapshot.checkpoint.channel_values.config = telemetryConfig;
       if (resumeStatePatch)
-        pending.graphSnapshot.checkpoint.channel_values.runtime = {
-          ...pending.graphSnapshot.checkpoint.channel_values.runtime,
-          ...resumeStatePatch
-        };
+        pending.graphSnapshot.checkpoint.channel_values.runtime = (0, import_utils.mergeRuntimeState)(
+          pending.graphSnapshot.checkpoint.channel_values.runtime,
+          resumeStatePatch
+        );
     }
     leaseAbort.signal.throwIfAborted();
     if (pending.graphSnapshot && frameworkAdapter)
@@ -9391,8 +9458,17 @@ async function tryPrepareResumeStream({
       resumeUpdate.runtime = resumeStatePatch;
     }
     const hasResumeUpdate = !isLimitPause && Object.keys(resumeUpdate).length > 0;
-    const resumeValue = isLimitPause ? void 0 : meta.hasValue && pending.schema.kind === "custom" ? meta.value : meta.selected?.length && pending.schema.kind === "multi-choice" ? meta.selected.map((x) => String(x)) : meta.selected?.length ? String(meta.selected[0]) : void 0;
+    const outstandingResponse = isLimitPause ? pending.graphSnapshot?.suspension?.response : void 0;
+    const humanValue = isLimitPause ? outstandingResponse?.value : meta.hasValue && pending.schema.kind === "custom" ? meta.value : meta.selected?.length && pending.schema.kind === "multi-choice" ? meta.selected.map((x) => String(x)) : meta.selected?.length ? String(meta.selected[0]) : void 0;
     const resumeCheckpointId = typeof pending.graphCheckpointId === "string" && pending.graphCheckpointId.length > 0 ? pending.graphCheckpointId : void 0;
+    const resumeDelivery = isLimitPause ? outstandingResponse : humanValue !== void 0 ? (0, import_runtime2.createResumeDelivery)(
+      pending.requestId,
+      pending.node,
+      pending.schema,
+      humanValue,
+      pending.graphSnapshot
+    ) : void 0;
+    const resumeValue = resumeDelivery ? (0, import_runtime2.resumeDeliveryInput)(resumeDelivery) : humanValue;
     const resumedGraph = await (0, import_runtime2.createExecutionGraph)(wf, {
       ...telemetryConfig,
       resume: true,
@@ -9400,6 +9476,8 @@ async function tryPrepareResumeStream({
       ...resumeCheckpointId ? { resumeCheckpointId } : {},
       ...hasResumeUpdate ? { resumeUpdate } : {}
     });
+    resumedGraph.execution ??= {};
+    resumedGraph.execution.resumeDelivery = resumeDelivery;
     await store.delete(pending.token);
     const response = meta.hasValue ? JSON.stringify(meta.value) : responseFromSelection(meta.selected);
     const telemetry = isRecord4(telemetryConfig.telemetry) ? telemetryConfig.telemetry : {};