@dudousxd/nestjs-agent-core 0.45.0 → 0.45.1

package/dist/index.cjs

@@ -256,6 +256,8 @@ __export(src_exports, {
   toActionProposalView: () => toActionProposalView,
   toolCallApprovalFromRow: () => toolCallApprovalFromRow,
   toolCallContext: () => toolCallContext,
+  toolCallUpdateForProposal: () => toolCallUpdateForProposal,
+  toolCallUpdateForTransition: () => toolCallUpdateForTransition,
   traceLlmTurn: () => traceLlmTurn,
   traceToolExecution: () => traceToolExecution,
   transitionActionProposalClaim: () => transitionActionProposalClaim,
@@ -8096,6 +8098,98 @@ ${toolText}`;
 }
 __name(runAgentLoop, "runAgentLoop");
 
+// src/action-proposal-tool-call.ts
+function toolCallUpdateForProposal(proposal) {
+  const audit = proposal.decisionAudit;
+  const toolCallId = proposal.originToolCallId;
+  const decidedBy = {
+    ...audit?.actorRef !== void 0 ? {
+      executedByRef: audit.actorRef
+    } : {},
+    ...audit?.via !== void 0 ? {
+      decidedVia: audit.via
+    } : {}
+  };
+  switch (proposal.decision) {
+    case "rejected":
+      return {
+        toolCallId,
+        status: "rejected",
+        ...decidedBy,
+        ...audit?.reason !== void 0 ? {
+          error: storableText2(audit.reason)
+        } : {}
+      };
+    case "expired":
+      return {
+        toolCallId,
+        status: "expired",
+        ...audit?.via !== void 0 ? {
+          decidedVia: audit.via
+        } : {}
+      };
+    case "superseded":
+      return {
+        toolCallId,
+        status: "expired",
+        decidedVia: audit?.via ?? "supersession",
+        error: proposal.supersededBy !== void 0 ? `superseded by proposal ${proposal.supersededBy}` : "superseded by a newer proposal"
+      };
+    case "approved": {
+      const execution = proposal.execution;
+      const remember = audit?.remember !== void 0 ? {
+        remember: audit.remember
+      } : {};
+      if (execution?.status === "succeeded") {
+        return {
+          toolCallId,
+          status: "executed",
+          ...storableOutput(execution.result) ? {
+            output: execution.result
+          } : {},
+          ...decidedBy,
+          ...remember
+        };
+      }
+      if (execution?.status === "failed") {
+        return {
+          toolCallId,
+          status: "failed",
+          error: storableText2(execution.error ?? "the approved action failed"),
+          ...decidedBy,
+          ...remember
+        };
+      }
+      return null;
+    }
+    default:
+      return null;
+  }
+}
+__name(toolCallUpdateForProposal, "toolCallUpdateForProposal");
+function toolCallUpdateForTransition(previous, next) {
+  const update = toolCallUpdateForProposal(next);
+  if (update === null) return null;
+  const before = previous === void 0 ? null : toolCallUpdateForProposal(previous);
+  return before?.status === update.status ? null : update;
+}
+__name(toolCallUpdateForTransition, "toolCallUpdateForTransition");
+function storableOutput(result2) {
+  if (result2 === void 0) return false;
+  let json;
+  try {
+    json = JSON.stringify(result2);
+  } catch {
+    return false;
+  }
+  return json !== void 0 && !/\\u0000|\\ud[89ab][0-9a-f]{2}(?!\\ud[c-f])|(?<!\\ud[89ab][0-9a-f]{2})\\ud[c-f][0-9a-f]{2}/i.test(json);
+}
+__name(storableOutput, "storableOutput");
+function storableText2(text) {
+  return text.replaceAll("\0", "");
+}
+__name(storableText2, "storableText");
+
 // src/in-memory-action-proposal-store.ts
 var import_node_crypto2 = require("crypto");
 var InMemoryActionProposalStore = class {
@@ -8142,9 +8236,19 @@ var InMemoryActionProposalStore = class {
       status: "not_found"
     };
     const result2 = transition(row2, this.clock());
-    if (result2.proposal) this.rows.set(id, snapshotActionProposal(result2.proposal));
+    if (result2.proposal) {
+      this.rows.set(id, snapshotActionProposal(result2.proposal));
+      this.proposalChanged(row2, result2.proposal);
+    }
     return result2;
   }
+  /**
+  * Called after every proposal transition, with the row before and after — synchronously, so no
+  * reader sees one without the other. {@link InMemoryAgentStore} settles the proposal's tool-call
+  * record here (see `toolCallUpdateForTransition`).
+  */
+  proposalChanged(_previous, _next) {
+  }
   async decideActionProposal(scope, id, command) {
     return this.mutate(scope, id, (row2, now) => transitionActionProposalDecision(row2, command, now));
   }
@@ -8225,7 +8329,11 @@ var InMemoryActionProposalStore = class {
       if (result2.proposal) replacements.push(result2.proposal);
     }
     this.rows.set(proposal.id, proposal);
-    for (const row2 of replacements) this.rows.set(row2.id, row2);
+    for (const row2 of replacements) {
+      const previous = this.rows.get(row2.id);
+      this.rows.set(row2.id, row2);
+      if (previous) this.proposalChanged(previous, row2);
+    }
     return {
       status: "created",
       proposal: snapshotActionProposal(proposal)
@@ -8946,6 +9054,15 @@ var InMemoryAgentStore = class extends InMemoryActionProposalStore {
     return settled;
   }
   async updateToolCall(input) {
+    this.applyToolCallUpdate(input);
+  }
+  /** An independent proposal moved: its `proposed` tool-call record follows it. */
+  proposalChanged(previous, next) {
+    const update = toolCallUpdateForTransition(previous, next);
+    if (update === null || this.toolCalls.get(update.toolCallId)?.proposalId !== next.id) return;
+    this.applyToolCallUpdate(update);
+  }
+  applyToolCallUpdate(input) {
     const row2 = this.toolCalls.get(input.toolCallId);
     if (row2 === void 0) {
       return;
@@ -10488,6 +10605,8 @@ __name(createFunctionalTool, "createFunctionalTool");
   toActionProposalView,
   toolCallApprovalFromRow,
   toolCallContext,
+  toolCallUpdateForProposal,
+  toolCallUpdateForTransition,
   traceLlmTurn,
   traceToolExecution,
   transitionActionProposalClaim,