@dudousxd/nestjs-agent-core 0.32.0 → 0.34.0

package/dist/index.js

@@ -2348,6 +2348,123 @@ function isControlFlowSignal(error) {
 }
 __name(isControlFlowSignal, "isControlFlowSignal");
 
+// src/dangling-tool-calls.ts
+var UNFINISHED_TOOL_CALL = "This tool call was never completed: the turn it belonged to ended unexpectedly before it was settled. Do not assume it ran, and do not assume it did not \u2014 check the current state with a read tool if one exists, tell the person plainly what is and is not confirmed, and do it again only if they still want it.";
+var RUN_ENDED_BEFORE_TOOL_CALL = "the run ended before this tool call was settled";
+var DECLINED = "The person was asked to approve this action and declined it. Nothing ran and nothing changed.";
+var EXPIRED = "This action needed approval, and the request expired before anyone decided. Nothing ran.";
+function danglingToolCallIds(messages) {
+  const ids = [];
+  for (const message of messages) {
+    const calls = message.toolCalls ?? [];
+    if (message.role !== "assistant" || calls.length === 0) {
+      continue;
+    }
+    const settled = new Set((message.toolResults ?? []).map((result) => result.id));
+    for (const call of calls) {
+      if (!settled.has(call.id)) {
+        ids.push(call.id);
+      }
+    }
+  }
+  return ids;
+}
+__name(danglingToolCallIds, "danglingToolCallIds");
+function resultFor(call, outcome) {
+  const base = {
+    id: call.id,
+    name: call.name
+  };
+  switch (outcome?.status) {
+    case "executed":
+    case "auto_executed":
+      return {
+        ...base,
+        output: outcome.output ?? null
+      };
+    case "failed":
+      return {
+        ...base,
+        output: null,
+        error: outcome.error ?? UNFINISHED_TOOL_CALL
+      };
+    case "rejected":
+      return {
+        ...base,
+        output: {
+          rejected: true
+        },
+        denied: true,
+        error: DECLINED
+      };
+    case "expired":
+      return {
+        ...base,
+        output: {
+          rejected: true,
+          expired: true
+        },
+        denied: true,
+        expired: true,
+        error: EXPIRED
+      };
+    default:
+      return {
+        ...base,
+        output: null,
+        error: UNFINISHED_TOOL_CALL
+      };
+  }
+}
+__name(resultFor, "resultFor");
+function settleDanglingToolCalls(messages, outcomes = []) {
+  const known = new Map(outcomes.map((outcome) => [
+    outcome.id,
+    outcome
+  ]));
+  return messages.map((message) => {
+    const calls = message.toolCalls ?? [];
+    if (message.role !== "assistant" || calls.length === 0) {
+      return message;
+    }
+    const results = message.toolResults ?? [];
+    const settled = new Set(results.map((result) => result.id));
+    const missing = calls.filter((call) => !settled.has(call.id));
+    if (missing.length === 0) {
+      return message;
+    }
+    return {
+      ...message,
+      toolResults: [
+        ...results,
+        ...missing.map((call) => resultFor(call, known.get(call.id)))
+      ]
+    };
+  });
+}
+__name(settleDanglingToolCalls, "settleDanglingToolCalls");
+
+// src/dead-run.ts
+var RUN_NOT_ACTIVE_CODE = "run_not_active";
+var RUN_NOT_ACTIVE_MESSAGE = "This request is no longer waiting for an answer: the turn it belonged to has ended. Send the message again.";
+var RUN_NO_LONGER_RUNNING = "the run is no longer running";
+async function settleDeadRun(store, input) {
+  const failure = input.failure;
+  if (failure !== void 0) {
+    await Promise.resolve(store.recordRunEnd?.({
+      runId: input.runId,
+      status: "failed",
+      errorCode: failure.code,
+      errorMessage: failure.message
+    })).catch(() => void 0);
+  }
+  await Promise.resolve(store.failUnsettledToolCalls?.(input.runId, RUN_ENDED_BEFORE_TOOL_CALL)).catch(() => 0);
+  if (input.threadId !== void 0) {
+    await releaseThreadRun(store, input.threadId, input.runId).catch(() => void 0);
+  }
+}
+__name(settleDeadRun, "settleDeadRun");
+
 // src/delegation.ts
 function normalizeDelegation(entry) {
   return typeof entry === "string" ? {
@@ -2812,9 +2929,46 @@ function agentFailureCode(error) {
   if (error instanceof StructuredOutputError) {
     return "structured_output_invalid";
   }
-  return "run_failed";
+  if (isReplayIntegrityError(error)) {
+    return "replay_diverged";
+  }
+  return isNoOutputError(error) ? "model_no_output" : "run_failed";
 }
 __name(agentFailureCode, "agentFailureCode");
+function isNoOutputError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return error.name === "AI_NoOutputGeneratedError" || error.name === "NoOutputGeneratedError" || error.message.startsWith("No output generated");
+}
+__name(isNoOutputError, "isNoOutputError");
+var RUN_FAILED_MESSAGE = "The assistant could not finish this answer. Please try again.";
+var streamErrorDetails;
+function exposeStreamErrorDetails(expose) {
+  streamErrorDetails = expose;
+}
+__name(exposeStreamErrorDetails, "exposeStreamErrorDetails");
+var WORDED_CODES = /* @__PURE__ */ new Set([
+  "quota_exceeded",
+  "output_rejected",
+  "structured_output_invalid"
+]);
+function streamFailure(error) {
+  const detail = error instanceof Error ? error.message : String(error);
+  const code = agentFailureCode(error);
+  if (WORDED_CODES.has(code)) {
+    return {
+      code,
+      message: detail
+    };
+  }
+  const exposed = streamErrorDetails ?? process.env.NODE_ENV !== "production";
+  return {
+    code,
+    message: exposed ? detail : RUN_FAILED_MESSAGE
+  };
+}
+__name(streamFailure, "streamFailure");
 var MAX_DELEGATION_DEPTH = 5;
 var DEFAULT_MAX_AGENT_APPEARANCES = 1;
 function delegationRefusal(args) {
@@ -3006,9 +3160,9 @@ function splitHistory(policy, input, messages) {
 }
 __name(splitHistory, "splitHistory");
 async function loadSelectedHistory(deps, input, hooks) {
-  return hooks.step("load:thread", async () => {
+  const recorded = await hooks.step("load:thread", async () => {
     const thread = await readThreadForTurn(deps, input.threadId);
-    const { keep, drop } = splitHistory(deps.historyPolicy, input, toModelMessages(thread.messages));
+    const { keep, drop } = splitHistory(deps.historyPolicy, input, await settleHistory(deps, toModelMessages(thread.messages)));
     return {
       messages: keep,
       dropped: deps.historyPolicy?.summarize === void 0 ? [] : drop,
@@ -3016,8 +3170,21 @@ async function loadSelectedHistory(deps, input, hooks) {
       hasAssistantMessage: thread.hasAssistantMessage
     };
   });
+  return {
+    ...recorded,
+    messages: settleDanglingToolCalls(recorded.messages)
+  };
 }
 __name(loadSelectedHistory, "loadSelectedHistory");
+async function settleHistory(deps, messages) {
+  const dangling = danglingToolCallIds(messages);
+  if (dangling.length === 0) {
+    return messages;
+  }
+  const outcomes = await Promise.resolve(deps.store.toolCallOutcomes?.(dangling) ?? []).catch(() => []);
+  return settleDanglingToolCalls(messages, outcomes);
+}
+__name(settleHistory, "settleHistory");
 async function readThreadForTurn(deps, threadId) {
   const windowing = deps.store;
   if (typeof windowing.loadThreadForTurn === "function") {
@@ -3057,7 +3224,7 @@ __name(turnMessageLimit, "turnMessageLimit");
 async function loadWholeThread(deps, input, hooks) {
   const thread = await hooks.step("load:thread", () => deps.store.getThread(input.threadId));
   const stored = thread?.messages ?? [];
-  const { keep, drop } = splitHistory(deps.historyPolicy, input, toModelMessages(stored));
+  const { keep, drop } = splitHistory(deps.historyPolicy, input, settleDanglingToolCalls(toModelMessages(stored)));
   return {
     messages: keep,
     dropped: drop,
@@ -3240,6 +3407,14 @@ async function awaitElicitation(hooks, request, ctx) {
   }, ctx));
 }
 __name(awaitElicitation, "awaitElicitation");
+function toolCallContext(ctx, toolCallId) {
+  return {
+    ...ctx,
+    toolCallId,
+    idempotencyKey: `${ctx.runId}:${toolCallId}`
+  };
+}
+__name(toolCallContext, "toolCallContext");
 function toolContext(deps, input, hooks) {
   return {
     actor: input.actor,
@@ -3679,7 +3854,7 @@ async function invokeClaimedTool(turn, claimed) {
         }, () => invokeWithTransientRetry(() => {
           ui2.restart();
           return deps.registry.invoke(call.name, call.input, {
-            ...ctx,
+            ...toolCallContext(ctx, call.id),
             emitUi: ui2.emit
           }, deps.rolesPolicy);
         }, deps.toolTransientRetry ?? {}, {
@@ -5074,6 +5249,13 @@ var InMemoryAgentStore = class {
         message.attachments = patch.attachments;
       }
     }
+    if (patch.interrupt !== void 0) {
+      if (patch.interrupt) {
+        message.interrupt = true;
+      } else {
+        delete message.interrupt;
+      }
+    }
     message.updatedAt = this.now();
     return {
       ...message
@@ -5270,6 +5452,36 @@ var InMemoryAgentStore = class {
       } : {}
     });
   }
+  async toolCallOutcomes(toolCallIds) {
+    const outcomes = [];
+    for (const id of toolCallIds) {
+      const row = this.toolCalls.get(id);
+      if (row !== void 0) {
+        outcomes.push({
+          id,
+          status: row.status,
+          ...row.output !== void 0 ? {
+            output: row.output
+          } : {},
+          ...row.error !== void 0 ? {
+            error: row.error
+          } : {}
+        });
+      }
+    }
+    return outcomes;
+  }
+  async failUnsettledToolCalls(runId, error) {
+    let settled = 0;
+    for (const row of this.toolCalls.values()) {
+      if (row.runId === runId && row.status === "pending_approval") {
+        row.status = "failed";
+        row.error = error;
+        settled += 1;
+      }
+    }
+    return settled;
+  }
   async updateToolCall(input) {
     const row = this.toolCalls.get(input.toolCallId);
     if (row === void 0) {
@@ -5596,6 +5808,11 @@ export {
   REMEMBER_TOOL_DESCRIPTION,
   REMEMBER_TOOL_NAME,
   REQUESTER_APPROVER,
+  RUN_ENDED_BEFORE_TOOL_CALL,
+  RUN_FAILED_MESSAGE,
+  RUN_NOT_ACTIVE_CODE,
+  RUN_NOT_ACTIVE_MESSAGE,
+  RUN_NO_LONGER_RUNNING,
   RunCancelledError,
   SKILL_TOOL_DESCRIPTION,
   SKILL_TOOL_NAME,
@@ -5606,6 +5823,7 @@ export {
   ToolInputInvalidError,
   ToolNotFoundError,
   ToolRegistry,
+  UNFINISHED_TOOL_CALL,
   actorScope,
   agentDiagnosticKey,
   agentFailureCode,
@@ -5623,6 +5841,7 @@ export {
   createIncrementalGate,
   createNoopEmitUi,
   createUiCollector,
+  danglingToolCallIds,
   dayBoundsUtc,
   decodeStreamEvent,
   defaultCanDecide,
@@ -5634,6 +5853,7 @@ export {
   estimateCost,
   estimateMessageTokens,
   exhaustedWindow,
+  exposeStreamErrorDetails,
   extractJson,
   filterToolsByAllowList,
   filterToolsByCanUse,
@@ -5696,6 +5916,8 @@ export {
   runOutputProcessors,
   seedModelPrices,
   settleAll,
+  settleDanglingToolCalls,
+  settleDeadRun,
   settleElicitation,
   settleUnsettledDelegation,
   skillInputSchema,
@@ -5704,9 +5926,11 @@ export {
   stampToolKinds,
   staticModelCatalog,
   staticSkillProvider,
+  streamFailure,
   summarizeWithModel,
   tenantScope,
   toolCallApprovalFromRow,
+  toolCallContext,
   traceLlmTurn,
   traceToolExecution,
   truncateDetailContent,