@kortyx/agent 0.32.0 → 0.33.0

package/dist/index.js

@@ -2247,7 +2247,8 @@ var require_dist2 = __commonJS({
       if (!value.result || typeof value.result !== "object") return void 0;
       return {
         status: "completed",
-        result: value.result
+        result: value.result,
+        ...Array.isArray(value.resolvedInterrupts) ? { resolvedInterrupts: value.resolvedInterrupts } : {}
       };
     };
     var resolveHookStatePatch = (args) => ({
@@ -2305,6 +2306,10 @@ var require_dist2 = __commonJS({
         raw,
         "useInterrupt response"
       );
+      if (args.onResolved) {
+        const { __kortyxResumeStatePatch: _patch, ...meta } = enrichedRequest.meta ?? {};
+        args.onResolved({ ...enrichedRequest, meta });
+      }
       return Promise.resolve(response);
     };
     var CONTROL_TOOL_PREFIX = "kortyx_request_input__";
@@ -4889,7 +4894,7 @@ ${tryStringify2(args.response)}`
           interruptInstructions: [
             "Human-input rules:",
             "- The kortyx_request_input__* tools pause this reasoning operation and return the validated human response as a normal tool result.",
-            "- Call at most one human-input tool in a model turn, and do not combine it with other tool calls in that turn.",
+            "- You may combine human-input tools with domain tools and output controls. Tools, emitted outputs, and human-input requests run in their requested order. Terminal output publishes last using the completed results.",
             interruptConfig.mode === "required" ? "- You must call at least one human-input tool before returning the final answer." : "- Human input is optional; call a human-input tool only when the request cannot be completed safely without it."
           ].join("\n")
         } : {},
@@ -4899,7 +4904,7 @@ ${tryStringify2(args.response)}`
             "- The kortyx_emit__* tools publish validated structured output and return an acknowledgement. You may continue with text or more tools afterward.",
             "- The kortyx_return__* tools publish a validated result and end this reasoning operation. If return tools are available, call exactly one before finishing.",
             "- For contracts with realtime streaming, use kortyx_stream_emit__* or kortyx_stream_return__*. These start a separate streamed JSON generation; its fields become visible as tokens arrive.",
-            "- Call a structured output control tool alone in its model turn."
+            "- You may combine multiple emit controls, domain tools, and human-input requests in one turn. Tools, emitted outputs, and human-input requests run in their requested order; the terminal return runs last. Outputs after domain tools or human input are regenerated using their completed results. Request at most one terminal return per turn."
           ].join("\n")
         } : {}
       });
@@ -4928,6 +4933,19 @@ ${tryStringify2(args.response)}`
       );
       let pending = checkpoint?.pending;
       let pendingStepIndex = checkpoint?.pendingStepIndex;
+      let outputContractCorrections = checkpoint?.outputContractCorrections ?? 0;
+      const correctionExhausted = () => {
+        const message = `useReason could not complete output-contract correction within toolExecution.maxSteps (${maxSteps}). Select exactly one terminal return contract; multiple emit contracts are allowed. Increase maxSteps to allow correction and output generation.`;
+        return new import_errors62.ProviderRequestError(message, {
+          code: "REASON_OUTPUT_CONTRACT_CORRECTION_EXHAUSTED",
+          operation: "useReason",
+          safeMessage: message,
+          retryable: false,
+          details: { maxSteps, outputContractCorrections }
+        });
+      };
+      const resolvedInterrupts = checkpoint?.resolvedInterrupts ?? [];
+      for (const request of resolvedInterrupts) ctx.node.replayInterrupt?.(request);
       const approvedCalls = checkpoint?.approvedCalls ?? [];
       const interruptHistory = checkpoint?.interruptHistory ?? [];
       const emissions = checkpoint?.emissions ?? [];
@@ -4939,8 +4957,10 @@ ${tryStringify2(args.response)}`
           messages,
           steps,
           approvedCalls,
+          resolvedInterrupts,
           interruptHistory,
           emissions,
+          outputContractCorrections,
           ...returned ? { returned } : {},
           finalizing,
           ...pending ? { pending } : {},
@@ -4948,6 +4968,10 @@ ${tryStringify2(args.response)}`
         };
         ctx.stateDirty = true;
       };
+      const rememberInterrupt = (request) => {
+        resolvedInterrupts.push(request);
+        save();
+      };
       const emitToolEvent = (event, payload) => {
         ctx.node.emit(event, {
           ...payload,
@@ -4957,7 +4981,7 @@ ${tryStringify2(args.response)}`
         });
       };
       try {
-        for (let stepIndex = pending ? pendingStepIndex ?? steps.length - 1 : steps.length; stepIndex < maxSteps; stepIndex += 1) {
+        for (let stepIndex = pending ? pendingStepIndex ?? steps.length - 1 : steps.length; stepIndex < maxSteps; stepIndex = steps.length) {
           (0, import_core52.throwIfExecutionAborted)(abortSignal);
           traceSpan?.addEvent?.("useReason.tool-step.start", {
             stepIndex,
@@ -5094,273 +5118,301 @@ ${tryStringify2(args.response)}`
           const outputCalls = toolCalls.filter(
             (call) => outputByToolName.has(call.name)
           );
-          if (outputCalls.length > 0) {
-            if (toolCalls.length !== 1)
-              throw new Error(
-                "A useReason output contract call must be the only tool call in its model turn."
-              );
-            const call = outputCalls[0];
-            if (!call) throw new Error("Missing useReason output control call.");
-            const resolved = outputByToolName.get(call.name);
-            if (!resolved)
-              throw new Error(
-                `Unknown useReason output contract tool "${call.name}".`
-              );
-            if (toolResults.some((result3) => result3.toolCallId === call.id)) {
-              pending = void 0;
-              pendingStepIndex = void 0;
-              save();
-              continue;
+          const returnCalls = outputCalls.filter(
+            (call) => outputByToolName.get(call.name)?.kind === "return"
+          );
+          if (returnCalls.length > 1) {
+            let corrected = false;
+            for (const call of returnCalls) {
+              if (toolResults.some((result3) => result3.toolCallId === call.id))
+                continue;
+              const result2 = {
+                toolCallId: call.id,
+                name: call.name,
+                isError: true,
+                content: "MULTIPLE_TERMINAL_OUTPUTS: No terminal output was published. Select exactly one return contract using the tool and human-input results. Do not repeat completed calls. Multiple emit contracts are allowed."
+              };
+              toolResults.push(result2);
+              messages.push({ role: "tool", ...result2 });
+              corrected = true;
             }
-            if (resolved.kind === "emit" && emissions.length >= (useReasonArgs.outputs?.maxEmissions ?? 16))
-              throw new Error(
-                `useReason reached outputs.maxEmissions (${useReasonArgs.outputs?.maxEmissions ?? 16}).`
+            if (corrected) outputContractCorrections += 1;
+            save();
+          }
+          const orderedCalls = [
+            ...toolCalls.filter(
+              (call) => outputByToolName.get(call.name)?.kind !== "return"
+            ),
+            ...returnCalls
+          ];
+          for (const toolCall of orderedCalls) {
+            (0, import_core52.throwIfExecutionAborted)(abortSignal);
+            if (outputByToolName.has(toolCall.name)) {
+              const call = toolCall;
+              const hasEvidenceCalls = toolResults.some(
+                (result3) => !outputByToolName.has(result3.name)
               );
-            let data;
-            if (resolved.stream) {
-              if (!stream)
+              const resolved = outputByToolName.get(call.name);
+              if (!resolved)
                 throw new Error(
-                  `useReason streaming output contract "${resolved.name}" requires stream: true.`
+                  `Unknown useReason output contract tool "${call.name}".`
                 );
-              if (stepIndex + 1 >= maxSteps)
-                throw new Error(
-                  `useReason output streaming requires another model pass within maxSteps (${maxSteps}).`
-                );
-              const instruction = call.input && typeof call.input === "object" && !Array.isArray(call.input) ? call.input.instruction : void 0;
-              if (typeof instruction !== "string" || instruction.trim().length === 0)
+              if (toolResults.some((result3) => result3.toolCallId === call.id)) {
+                if (resolved.kind === "return" && returned) completed = true;
+                continue;
+              }
+              if (resolved.kind === "emit" && emissions.length >= (useReasonArgs.outputs?.maxEmissions ?? 16))
                 throw new Error(
-                  `useReason streaming output contract "${resolved.name}" requires an instruction.`
-                );
-              const streamId = `${opId}:${resolved.kind}:${resolved.name}:${resolved.kind === "emit" ? emissions.length : "return"}`;
-              const structured = {
-                dataType: resolved.contract.schemaId,
-                schemaId: resolved.contract.schemaId,
-                schemaVersion: resolved.contract.schemaVersion,
-                fields: resolved.contract.stream?.fields
-              };
-              const inferred = inferOutputFormat(
-                resolved.contract.schema,
-                void 0
-              );
-              try {
-                const outputStep = await reasonEngine(
-                  {
-                    ...useReasonArgs,
-                    tools: [],
-                    ...inferred.responseFormat ? { responseFormat: inferred.responseFormat } : {},
-                    messages: [
-                      ...messages,
-                      {
-                        role: "tool",
-                        toolCallId: call.id,
-                        name: call.name,
-                        content: "Generating the requested structured output."
-                      },
-                      {
-                        role: "user",
-                        content: withOutputGuardrails(
-                          instruction,
-                          resolved.contract.schema
-                        )
-                      }
-                    ],
-                    emit: false,
-                    stream,
-                    ...emit && stream ? {
-                      onTextChunk: createStructuredOutputStreamer(
-                        { structured },
-                        id3,
-                        streamId
-                      )
-                    } : {}
-                  },
-                  { ...id3 ? { id: id3 } : {}, opId }
+                  `useReason reached outputs.maxEmissions (${useReasonArgs.outputs?.maxEmissions ?? 16}).`
                 );
-                if (outputStep.toolCalls?.length)
+              let data;
+              if (resolved.stream || hasEvidenceCalls) {
+                if (resolved.stream && !stream)
                   throw new Error(
-                    `Provider requested a tool during streamed output contract "${resolved.name}".`
+                    `useReason streaming output contract "${resolved.name}" requires stream: true.`
                   );
-                aggregatedUsage = mergeUsage(aggregatedUsage, outputStep.usage);
-                accumulateTokenUsage(outputStep.usage);
-                aggregatedWarnings = mergeWarnings(
-                  aggregatedWarnings,
-                  mergeWarnings(inferred.warnings, outputStep.warnings)
-                );
-                aggregatedProviderMetadata = mergeProviderMetadata(
-                  aggregatedProviderMetadata,
-                  outputStep.providerMetadata
+                if (steps.length >= maxSteps) {
+                  const message = `useReason output generation requires another model pass within toolExecution.maxSteps (${maxSteps}). Increase maxSteps to allow outputs to use completed tool and interrupt results.`;
+                  throw new import_errors62.ProviderRequestError(message, {
+                    code: "REASON_OUTPUT_BUDGET_EXHAUSTED",
+                    operation: "useReason",
+                    safeMessage: message,
+                    retryable: false,
+                    details: { maxSteps, modelPasses: steps.length }
+                  });
+                }
+                const streamInstruction = call.input && typeof call.input === "object" && !Array.isArray(call.input) ? call.input.instruction : void 0;
+                if (resolved.stream && (typeof streamInstruction !== "string" || streamInstruction.trim().length === 0))
+                  throw new Error(
+                    `useReason streaming output contract "${resolved.name}" requires an instruction.`
+                  );
+                const instruction = [
+                  `Generate output contract "${resolved.name}": ${resolved.contract.description}`,
+                  "Use the completed tool and human-input results. Do not assume results for pending calls.",
+                  resolved.stream ? String(streamInstruction) : `Regenerate this original draft, which was written before those results were available: ${JSON.stringify(call.input)}`
+                ].join("\n\n");
+                const streamId = `${opId}:${resolved.kind}:${resolved.name}:${resolved.kind === "emit" ? emissions.length : "return"}`;
+                const structured = {
+                  dataType: resolved.contract.schemaId,
+                  schemaId: resolved.contract.schemaId,
+                  schemaVersion: resolved.contract.schemaVersion,
+                  fields: resolved.contract.stream?.fields
+                };
+                const inferred = inferOutputFormat(
+                  resolved.contract.schema,
+                  void 0
                 );
-                finalFinishReason = outputStep.finishReason;
-                finalRaw = outputStep.raw;
-                data = parseReasonOutputWithSchema({
-                  text: outputStep.text,
-                  schema: resolved.contract.schema,
-                  ...outputStep.finishReason ? { finishReason: outputStep.finishReason } : {},
-                  ...aggregatedUsage ? { usage: aggregatedUsage } : {},
-                  label: `useReason output contract "${resolved.name}"`
-                });
-                steps.push({
-                  stepIndex: stepIndex + 1,
+                const outputRecord = {
+                  stepIndex: steps.length,
                   kind: "output",
-                  text: outputStep.text,
+                  text: "",
                   toolCalls: [],
-                  toolResults: [],
-                  ...outputStep.usage ? { usage: outputStep.usage } : {},
-                  ...outputStep.finishReason ? { finishReason: outputStep.finishReason } : {},
-                  ...outputStep.providerMetadata ? { providerMetadata: outputStep.providerMetadata } : {},
-                  ...outputStep.warnings ? { warnings: outputStep.warnings } : {}
-                });
-                stepIndex += 1;
-              } catch (error) {
-                traceSpan?.addEvent?.("useReason.output.invalidated", {
-                  contract: resolved.name,
-                  kind: resolved.kind,
-                  schemaId: resolved.contract.schemaId,
-                  schemaVersion: resolved.contract.schemaVersion,
-                  streamId
-                });
-                if (emit) {
-                  try {
-                    ctx.node.emit("structured_data_invalidated", {
-                      node: ctx.node.graph.node,
-                      streamId
-                    });
-                  } catch {
+                  toolResults: []
+                };
+                steps.push(outputRecord);
+                save();
+                try {
+                  const outputStep = await reasonEngine(
+                    {
+                      ...useReasonArgs,
+                      tools: [],
+                      ...inferred.responseFormat ? { responseFormat: inferred.responseFormat } : {},
+                      messages: [
+                        ...messages,
+                        ...toolCalls.filter(
+                          (pendingCall) => !toolResults.some(
+                            (result3) => result3.toolCallId === pendingCall.id
+                          )
+                        ).map(
+                          (pendingCall) => ({
+                            role: "tool",
+                            toolCallId: pendingCall.id,
+                            name: pendingCall.name,
+                            content: "This call has not completed yet. Use only completed results; do not assume a result for this pending call."
+                          })
+                        ),
+                        {
+                          role: "user",
+                          content: withOutputGuardrails(
+                            instruction,
+                            resolved.contract.schema
+                          )
+                        }
+                      ],
+                      emit: false,
+                      stream: resolved.stream && stream,
+                      ...emit && resolved.stream && stream ? {
+                        onTextChunk: createStructuredOutputStreamer(
+                          { structured },
+                          id3,
+                          streamId
+                        )
+                      } : {}
+                    },
+                    { ...id3 ? { id: id3 } : {}, opId }
+                  );
+                  if (outputStep.toolCalls?.length)
+                    throw new Error(
+                      `Provider requested a tool during streamed output contract "${resolved.name}".`
+                    );
+                  aggregatedUsage = mergeUsage(aggregatedUsage, outputStep.usage);
+                  accumulateTokenUsage(outputStep.usage);
+                  aggregatedWarnings = mergeWarnings(
+                    aggregatedWarnings,
+                    mergeWarnings(inferred.warnings, outputStep.warnings)
+                  );
+                  aggregatedProviderMetadata = mergeProviderMetadata(
+                    aggregatedProviderMetadata,
+                    outputStep.providerMetadata
+                  );
+                  finalFinishReason = outputStep.finishReason;
+                  finalRaw = outputStep.raw;
+                  Object.assign(outputRecord, {
+                    stepIndex: outputRecord.stepIndex,
+                    kind: "output",
+                    text: outputStep.text,
+                    toolCalls: [],
+                    toolResults: [],
+                    ...outputStep.usage ? { usage: outputStep.usage } : {},
+                    ...outputStep.finishReason ? { finishReason: outputStep.finishReason } : {},
+                    ...outputStep.providerMetadata ? { providerMetadata: outputStep.providerMetadata } : {},
+                    ...outputStep.warnings ? { warnings: outputStep.warnings } : {}
+                  });
+                  save();
+                  data = parseReasonOutputWithSchema({
+                    text: outputStep.text,
+                    schema: resolved.contract.schema,
+                    ...outputStep.finishReason ? { finishReason: outputStep.finishReason } : {},
+                    ...aggregatedUsage ? { usage: aggregatedUsage } : {},
+                    label: `useReason output contract "${resolved.name}"`
+                  });
+                } catch (error) {
+                  traceSpan?.addEvent?.("useReason.output.invalidated", {
+                    contract: resolved.name,
+                    kind: resolved.kind,
+                    schemaId: resolved.contract.schemaId,
+                    schemaVersion: resolved.contract.schemaVersion,
+                    streamId
+                  });
+                  if (emit && resolved.stream) {
+                    try {
+                      ctx.node.emit("structured_data_invalidated", {
+                        node: ctx.node.graph.node,
+                        streamId
+                      });
+                    } catch {
+                    }
                   }
+                  throw error;
                 }
-                throw error;
+              } else {
+                data = parseWithSchema(
+                  resolved.contract.schema,
+                  call.input,
+                  `useReason output contract "${resolved.name}"`
+                );
               }
-            } else {
-              data = parseWithSchema(
-                resolved.contract.schema,
-                call.input,
-                `useReason output contract "${resolved.name}"`
-              );
-            }
-            const entry = { contract: resolved.name, data };
-            const emissionIndex = emissions.length;
-            if (resolved.kind === "emit")
-              emissions.push(entry);
-            else returned = entry;
-            if (emit)
-              emitStructuredData({
-                kind: "final",
-                data,
-                dataType: resolved.contract.schemaId,
+              const entry = { contract: resolved.name, data };
+              const emissionIndex = emissions.length;
+              if (resolved.kind === "emit")
+                emissions.push(entry);
+              else returned = entry;
+              if (emit)
+                emitStructuredData({
+                  kind: "final",
+                  data,
+                  dataType: resolved.contract.schemaId,
+                  schemaId: resolved.contract.schemaId,
+                  schemaVersion: resolved.contract.schemaVersion,
+                  streamId: `${opId}:${resolved.kind}:${resolved.name}:${resolved.kind === "emit" ? emissionIndex : "return"}`,
+                  ...id3 ? { id: id3 } : {}
+                });
+              traceSpan?.addEvent?.("useReason.output.emitted", {
+                contract: resolved.name,
+                kind: resolved.kind,
                 schemaId: resolved.contract.schemaId,
                 schemaVersion: resolved.contract.schemaVersion,
-                streamId: `${opId}:${resolved.kind}:${resolved.name}:${resolved.kind === "emit" ? emissionIndex : "return"}`,
-                ...id3 ? { id: id3 } : {}
+                emissionIndex,
+                data
               });
-            traceSpan?.addEvent?.("useReason.output.emitted", {
-              contract: resolved.name,
-              kind: resolved.kind,
-              schemaId: resolved.contract.schemaId,
-              schemaVersion: resolved.contract.schemaVersion,
-              emissionIndex,
-              data
-            });
-            if (resolved.kind === "return") {
-              pending = void 0;
-              pendingStepIndex = void 0;
-              completed = true;
+              const result2 = normalizeToolResult(call, { emitted: true, data });
+              toolResults.push(result2);
+              messages.push({
+                role: "tool",
+                content: result2.content,
+                toolCallId: result2.toolCallId,
+                name: result2.name
+              });
+              if (resolved.kind === "return") completed = true;
               save();
-              break;
+              continue;
             }
-            const result2 = normalizeToolResult(call, { emitted: true, data });
-            toolResults.push(result2);
-            messages.push({
-              role: "tool",
-              content: result2.content,
-              toolCallId: result2.toolCallId,
-              name: result2.name
-            });
-            pending = void 0;
-            pendingStepIndex = void 0;
-            save();
-            continue;
-          }
-          const interruptCalls = toolCalls.filter(
-            (call) => interruptByToolName.has(call.name)
-          );
-          if (interruptCalls.length > 0) {
-            if (toolCalls.length !== 1)
-              throw new Error(
-                "A useReason interrupt contract call must be the only tool call in its model turn."
-              );
-            const interruptCall = interruptCalls[0];
-            if (!interruptCall)
-              throw new Error("Missing useReason interrupt control call.");
-            if (interruptHistory.length >= (interruptConfig?.maxRequests ?? 1))
-              throw new Error(
-                `useReason reached interrupts.maxRequests (${interruptConfig?.maxRequests ?? 1}).`
-              );
-            const resolved = interruptByToolName.get(interruptCall.name);
-            if (!resolved)
-              throw new Error(
-                `Unknown useReason interrupt contract tool "${interruptCall.name}".`
+            if (interruptByToolName.has(toolCall.name)) {
+              const resolved = interruptByToolName.get(toolCall.name);
+              if (!resolved)
+                throw new Error(
+                  `Unknown useReason interrupt contract tool "${toolCall.name}".`
+                );
+              if (toolResults.some((result3) => result3.toolCallId === toolCall.id)) {
+                continue;
+              }
+              if (interruptHistory.length >= (interruptConfig?.maxRequests ?? 1))
+                throw new Error(
+                  `useReason reached interrupts.maxRequests (${interruptConfig?.maxRequests ?? 1}).`
+                );
+              const request = parseWithSchema(
+                resolved.contract.requestSchema,
+                toolCall.input,
+                `useReason interrupt contract "${resolved.name}" request`
               );
-            if (toolResults.some((result3) => result3.toolCallId === interruptCall.id)) {
-              pending = void 0;
-              pendingStepIndex = void 0;
+              traceSpan?.addEvent?.("useReason.interrupt.requested", {
+                checkpointKey,
+                contract: resolved.name,
+                interruptIndex: interruptHistory.length
+              });
+              const question = request && typeof request === "object" && !Array.isArray(request) && typeof request.question === "string" ? String(request.question) : void 0;
+              const response = await awaitInterruptInternal({
+                onResolved: rememberInterrupt,
+                request: {
+                  kind: "custom",
+                  request,
+                  contract: resolved.name,
+                  ...question ? { question } : {},
+                  schemaId: resolved.contract.schemaId,
+                  schemaVersion: resolved.contract.schemaVersion
+                },
+                responseSchema: resolved.contract.responseSchema,
+                id: `${id3 ?? "reason"}:${resolved.name}:${interruptHistory.length + 1}`,
+                meta: {
+                  __kortyxReason: {
+                    opId,
+                    stepIndex,
+                    interruptIndex: interruptHistory.length,
+                    contract: resolved.name
+                  }
+                }
+              });
+              const result2 = normalizeToolResult(toolCall, response);
+              toolResults.push(result2);
+              messages.push({
+                role: "tool",
+                content: result2.content,
+                toolCallId: result2.toolCallId,
+                name: result2.name
+              });
+              interruptHistory.push({
+                contract: resolved.name,
+                request,
+                response
+              });
+              traceSpan?.addEvent?.("useReason.interrupt.resolved", {
+                checkpointKey,
+                contract: resolved.name,
+                interruptIndex: interruptHistory.length - 1
+              });
               save();
               continue;
             }
-            const request = parseWithSchema(
-              resolved.contract.requestSchema,
-              interruptCall.input,
-              `useReason interrupt contract "${resolved.name}" request`
-            );
-            traceSpan?.addEvent?.("useReason.interrupt.requested", {
-              checkpointKey,
-              contract: resolved.name,
-              interruptIndex: interruptHistory.length
-            });
-            const question = request && typeof request === "object" && !Array.isArray(request) && typeof request.question === "string" ? String(request.question) : void 0;
-            const response = await awaitInterruptInternal({
-              request: {
-                kind: "custom",
-                request,
-                contract: resolved.name,
-                ...question ? { question } : {},
-                schemaId: resolved.contract.schemaId,
-                schemaVersion: resolved.contract.schemaVersion
-              },
-              responseSchema: resolved.contract.responseSchema,
-              id: `${id3 ?? "reason"}:${resolved.name}:${interruptHistory.length + 1}`,
-              meta: {
-                __kortyxReason: {
-                  opId,
-                  stepIndex,
-                  interruptIndex: interruptHistory.length,
-                  contract: resolved.name
-                }
-              }
-            });
-            const result2 = normalizeToolResult(interruptCall, response);
-            toolResults.push(result2);
-            messages.push({
-              role: "tool",
-              content: result2.content,
-              toolCallId: result2.toolCallId,
-              name: result2.name
-            });
-            interruptHistory.push({
-              contract: resolved.name,
-              request,
-              response
-            });
-            traceSpan?.addEvent?.("useReason.interrupt.resolved", {
-              checkpointKey,
-              contract: resolved.name,
-              interruptIndex: interruptHistory.length - 1
-            });
-            pending = void 0;
-            pendingStepIndex = void 0;
-            save();
-            continue;
-          }
-          for (const toolCall of toolCalls) {
             if (toolResults.some((result2) => result2.toolCallId === toolCall.id)) {
               await replayToolObservations(
                 steps[stepIndex]?.toolObservations?.filter(
@@ -5406,6 +5458,7 @@ ${tryStringify2(args.response)}`
                 "waiting"
               );
               const approval = await awaitInterruptInternal({
+                onResolved: rememberInterrupt,
                 id: `tool:${toolCall.id}`,
                 request: {
                   kind: "choice",
@@ -5520,22 +5573,24 @@ ${tryStringify2(args.response)}`
                 });
               }
             }
-            const completed2 = toolResults.at(-1);
-            if (completed2)
+            const completedToolResult = toolResults.at(-1);
+            if (completedToolResult)
               messages.push({
                 role: "tool",
-                content: completed2.content,
-                toolCallId: completed2.toolCallId,
-                name: completed2.name,
-                ...completed2.isError !== void 0 ? { isError: completed2.isError } : {}
+                content: completedToolResult.content,
+                toolCallId: completedToolResult.toolCallId,
+                name: completedToolResult.name,
+                ...completedToolResult.isError !== void 0 ? { isError: completedToolResult.isError } : {}
               });
             save();
           }
           pending = void 0;
           pendingStepIndex = void 0;
           save();
+          if (completed) break;
         }
         if (!completed) {
+          if (outputContractCorrections > 0) throw correctionExhausted();
           throw new Error(
             `useReason tool loop reached maxSteps (${maxSteps}) before producing a final response.`
           );
@@ -5597,7 +5652,11 @@ ${tryStringify2(args.response)}`
             output: useReasonArgs.telemetry?.output ?? returned?.data ?? finalOutput ?? finalText
           }
         });
-        ctx.currentNodeState.byKey[checkpointKey] = { status: "completed", result };
+        ctx.currentNodeState.byKey[checkpointKey] = {
+          status: "completed",
+          result,
+          resolvedInterrupts
+        };
         ctx.stateDirty = true;
         return result;
       } catch (error) {
@@ -5672,6 +5731,8 @@ ${tryStringify2(args.response)}`
       const opId = checkpointValue && typeof checkpointValue === "object" && "status" in checkpointValue && checkpointValue.status === "tool_loop" && "opId" in checkpointValue && typeof checkpointValue.opId === "string" ? checkpointValue.opId : provisionalOpId;
       const existingCompleted = readReasonCompletedCheckpoint(checkpointValue);
       if (existingCompleted) {
+        for (const request of existingCompleted.resolvedInterrupts ?? [])
+          ctx.node.replayInterrupt?.(request);
         await replayToolObservations(
           existingCompleted.result.steps?.flatMap(
             (step) => step.toolObservations ?? []