@dudousxd/nestjs-agent-core 0.45.0 → 0.45.2

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,
@@ -5964,7 +5966,7 @@ function traceToolExecution(runId, call, run) {
 }
 __name(traceToolExecution, "traceToolExecution");
 function toModelMessages(messages) {
-  return messages.map((message) => ({
+  return withoutBlankAssistantMessages(messages.map((message) => ({
     role: message.role,
     content: message.content,
     ...message.toolCalls !== void 0 ? {
@@ -5976,9 +5978,17 @@ function toModelMessages(messages) {
     ...message.attachments !== void 0 ? {
       attachments: message.attachments
     } : {}
-  }));
+  })));
 }
 __name(toModelMessages, "toModelMessages");
+function isBlankAssistantMessage(message) {
+  return message.role === "assistant" && message.content.trim().length === 0 && (message.toolCalls?.length ?? 0) === 0 && (message.toolResults?.length ?? 0) === 0;
+}
+__name(isBlankAssistantMessage, "isBlankAssistantMessage");
+function withoutBlankAssistantMessages(messages) {
+  return messages.some(isBlankAssistantMessage) ? messages.filter((message) => !isBlankAssistantMessage(message)) : messages;
+}
+__name(withoutBlankAssistantMessages, "withoutBlankAssistantMessages");
 function historyContext(input) {
   return {
     threadId: input.threadId,
@@ -6010,7 +6020,7 @@ async function loadSelectedHistory(deps, input, hooks) {
   });
   return {
     ...recorded,
-    messages: settleDanglingToolCalls(recorded.messages)
+    messages: settleDanglingToolCalls(withoutBlankAssistantMessages(recorded.messages))
   };
 }
 __name(loadSelectedHistory, "loadSelectedHistory");
@@ -7778,13 +7788,18 @@ ${block}`;
         runId: hooks.runId,
         step: i,
         count
-      }, () => generateFollowUps(deps.model, [
-        ...modelMessages,
-        {
-          role: "assistant",
-          content: turn.text
-        }
-      ], count), (result2) => ({
+      }, () => generateFollowUps(
+        deps.model,
+        // A blank answer is left off: an empty assistant message gets the call refused.
+        turn.text.trim().length > 0 ? [
+          ...modelMessages,
+          {
+            role: "assistant",
+            content: turn.text
+          }
+        ] : modelMessages,
+        count
+      ), (result2) => ({
         followUps: result2.followUps.length,
         inputTokens: result2.usage.inputTokens,
         outputTokens: result2.usage.outputTokens,
@@ -7852,7 +7867,8 @@ ${block}`;
       ...synthetic.map((entry) => entry.call)
     ];
     const syntheticResults = synthetic.map((entry) => entry.result);
-    const assistant = await hooks.step(`persist:assistant:${i}`, () => deps.store.appendMessage({
+    const blankStep = turn.text.trim().length === 0 && messageCalls.length === 0 && syntheticResults.length === 0 && (turn.ui === void 0 || turn.ui.length === 0) && turn.reasoning === void 0 && followUps === void 0;
+    const assistant = await hooks.step(`persist:assistant:${i}`, () => blankStep ? Promise.resolve(null) : deps.store.appendMessage({
       threadId: input.threadId,
       role: "assistant",
       content: turn.text,
@@ -7898,6 +7914,23 @@ ${block}`;
         toolResults: syntheticResults
       } : {}
     };
+    const finishFinalStep = /* @__PURE__ */ __name(() => hooks.step(`stream:step-finish:${i}`, async () => {
+      await writer.write(encodeStreamEvent({
+        kind: "step-finish",
+        usage: turn.usage,
+        costUsd,
+        ...turn.reasoningMs !== void 0 ? {
+          reasoningMs: turn.reasoningMs
+        } : {},
+        ...stepModel !== void 0 ? {
+          model: stepModel
+        } : {}
+      }));
+    }), "finishFinalStep");
+    if (assistant === null) {
+      await finishFinalStep();
+      break;
+    }
     modelMessages.push(assistantMessage);
     for (const entry of synthetic) {
       const { call, result: result2 } = entry;
@@ -7931,19 +7964,7 @@ ${block}`;
       });
     }
     if (isFinalTurn) {
-      await hooks.step(`stream:step-finish:${i}`, async () => {
-        await writer.write(encodeStreamEvent({
-          kind: "step-finish",
-          usage: turn.usage,
-          costUsd,
-          ...turn.reasoningMs !== void 0 ? {
-            reasoningMs: turn.reasoningMs
-          } : {},
-          ...stepModel !== void 0 ? {
-            model: stepModel
-          } : {}
-        }));
-      });
+      await finishFinalStep();
       break;
     }
     await haltIfCancelled(hooks, cancellable, `cancel:tools:${i}`);
@@ -8054,13 +8075,15 @@ ${toolText}`;
         return;
       }
       const agent = input.agentName ?? "default";
-      await deps.store.appendMessage({
-        threadId: delivery.threadId,
-        role: "assistant",
-        content: lastText,
-        agentName: agent,
-        runId: hooks.runId
-      });
+      if (lastText.trim().length > 0) {
+        await deps.store.appendMessage({
+          threadId: delivery.threadId,
+          role: "assistant",
+          content: lastText,
+          agentName: agent,
+          runId: hooks.runId
+        });
+      }
       await deps.store.updateToolCall({
         toolCallId: delivery.toolCallId,
         status: "executed",
@@ -8096,6 +8119,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 +8257,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 +8350,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 +9075,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 +10626,8 @@ __name(createFunctionalTool, "createFunctionalTool");
   toActionProposalView,
   toolCallApprovalFromRow,
   toolCallContext,
+  toolCallUpdateForProposal,
+  toolCallUpdateForTransition,
   traceLlmTurn,
   traceToolExecution,
   transitionActionProposalClaim,