@dudousxd/nestjs-agent 0.8.1 → 0.9.0

package/dist/durable/index.d.cts

@@ -1,6 +1,6 @@
 import { LlmStepEnvelope, ModelTurnResult, ToolStepEnvelope, AgentStore, AgentRunInput, AgentRunner, Decision } from '@dudousxd/nestjs-agent-core';
 import { WorkflowCtx } from '@dudousxd/nestjs-durable-core';
-import { A as AgentDepsFactory, a as AgentModuleOptions } from '../agent-deps.factory-BlC9tumI.cjs';
+import { A as AgentDepsFactory, a as AgentModuleOptions } from '../agent-deps.factory-DNslT7_J.cjs';
 import { WorkflowService } from '@dudousxd/nestjs-durable';
 import { DynamicModule } from '@nestjs/common';
 
@@ -56,9 +56,14 @@ declare class AgentRunSteps {
      */
     llm(input: DispatchedLlmInput): Promise<ModelTurnResult>;
     /**
-     * No retries — a tool may not be idempotent (a bare `@Step()` carries none, unlike `llm` above).
-     * The timeout is applied HERE, handler-side, via `withToolTimeout` — never as a durable dispatch
-     * `timeoutMs`, which bounds engine liveness (retryable) rather than the tool's own business outcome.
+     * NO DURABLE retries — a tool may not be idempotent (a bare `@Step()` carries none, unlike `llm`
+     * above). What it does retry, in place, is a CLASSIFIED-TRANSIENT error from the tool's own
+     * invocation (a DB deadlock, a lock-wait timeout — see `isTransientToolError`): the server rolled
+     * that work back, so re-invoking it is safe, and doing it here (inside this one step, never a new
+     * checkpoint) is exactly how the non-dispatched loop path handles it too. The timeout is applied
+     * HERE, handler-side, via `withToolTimeout` — never as a durable dispatch `timeoutMs`, which
+     * bounds engine liveness (retryable) rather than the tool's own business outcome — and per
+     * ATTEMPT, so a retried invocation gets its own fresh timeout window.
      */
     tool(input: DispatchedToolInput): Promise<unknown>;
 }

package/dist/durable/index.d.ts

@@ -1,6 +1,6 @@
 import { LlmStepEnvelope, ModelTurnResult, ToolStepEnvelope, AgentStore, AgentRunInput, AgentRunner, Decision } from '@dudousxd/nestjs-agent-core';
 import { WorkflowCtx } from '@dudousxd/nestjs-durable-core';
-import { A as AgentDepsFactory, a as AgentModuleOptions } from '../agent-deps.factory-BlC9tumI.js';
+import { A as AgentDepsFactory, a as AgentModuleOptions } from '../agent-deps.factory-DNslT7_J.js';
 import { WorkflowService } from '@dudousxd/nestjs-durable';
 import { DynamicModule } from '@nestjs/common';
 
@@ -56,9 +56,14 @@ declare class AgentRunSteps {
      */
     llm(input: DispatchedLlmInput): Promise<ModelTurnResult>;
     /**
-     * No retries — a tool may not be idempotent (a bare `@Step()` carries none, unlike `llm` above).
-     * The timeout is applied HERE, handler-side, via `withToolTimeout` — never as a durable dispatch
-     * `timeoutMs`, which bounds engine liveness (retryable) rather than the tool's own business outcome.
+     * NO DURABLE retries — a tool may not be idempotent (a bare `@Step()` carries none, unlike `llm`
+     * above). What it does retry, in place, is a CLASSIFIED-TRANSIENT error from the tool's own
+     * invocation (a DB deadlock, a lock-wait timeout — see `isTransientToolError`): the server rolled
+     * that work back, so re-invoking it is safe, and doing it here (inside this one step, never a new
+     * checkpoint) is exactly how the non-dispatched loop path handles it too. The timeout is applied
+     * HERE, handler-side, via `withToolTimeout` — never as a durable dispatch `timeoutMs`, which
+     * bounds engine liveness (retryable) rather than the tool's own business outcome — and per
+     * ATTEMPT, so a retried invocation gets its own fresh timeout window.
      */
     tool(input: DispatchedToolInput): Promise<unknown>;
 }

package/dist/durable/index.js

@@ -24,7 +24,7 @@ function childSinkWriter(writer) {
 __name(childSinkWriter, "childSinkWriter");
 
 // src/durable/agent-run.steps.ts
-import { AGENT_DEPS_FACTORY, traceLlmTurn, traceToolExecution, withToolTimeout } from "@dudousxd/nestjs-agent-core";
+import { AGENT_DEPS_FACTORY, invokeWithTransientRetry, publishAgentToolRetry, traceLlmTurn, traceToolExecution, withToolTimeout } from "@dudousxd/nestjs-agent-core";
 import { Step } from "@dudousxd/nestjs-durable";
 import { Inject, Injectable } from "@nestjs/common";
 function _ts_decorate(decorators, target, key, desc) {
@@ -71,23 +71,45 @@ var AgentRunSteps = class {
     }));
   }
   /**
-  * No retries — a tool may not be idempotent (a bare `@Step()` carries none, unlike `llm` above).
-  * The timeout is applied HERE, handler-side, via `withToolTimeout` — never as a durable dispatch
-  * `timeoutMs`, which bounds engine liveness (retryable) rather than the tool's own business outcome.
+  * NO DURABLE retries — a tool may not be idempotent (a bare `@Step()` carries none, unlike `llm`
+  * above). What it does retry, in place, is a CLASSIFIED-TRANSIENT error from the tool's own
+  * invocation (a DB deadlock, a lock-wait timeout — see `isTransientToolError`): the server rolled
+  * that work back, so re-invoking it is safe, and doing it here (inside this one step, never a new
+  * checkpoint) is exactly how the non-dispatched loop path handles it too. The timeout is applied
+  * HERE, handler-side, via `withToolTimeout` — never as a durable dispatch `timeoutMs`, which
+  * bounds engine liveness (retryable) rather than the tool's own business outcome — and per
+  * ATTEMPT, so a retried invocation gets its own fresh timeout window.
   */
   async tool(input) {
     const deps = this.factory.forAgent(input.ctx.agentName);
     const ctx = {
       ...input.ctx
     };
+    const localClassify = deps.toolTransientRetry !== false ? deps.toolTransientRetry?.classify : void 0;
+    const transientRetry = input.transientRetry === false ? false : {
+      attempts: input.transientRetry.attempts,
+      backoffMs: input.transientRetry.backoffMs,
+      ...localClassify !== void 0 ? {
+        classify: localClassify
+      } : {}
+    };
     return traceToolExecution(input.ctx.runId, {
       toolCallId: input.toolCallId,
       toolName: input.toolName,
       toolType: input.toolType
-    }, () => {
+    }, () => invokeWithTransientRetry(() => {
       const invocation = deps.registry.invoke(input.toolName, input.input, ctx, deps.rolesPolicy);
       return input.timeoutMs !== void 0 ? withToolTimeout(invocation, input.timeoutMs, input.toolName) : invocation;
-    });
+    }, transientRetry, {
+      onRetry: /* @__PURE__ */ __name((attempt, error) => {
+        publishAgentToolRetry({
+          toolName: input.toolName,
+          toolCallId: input.toolCallId,
+          attempt,
+          message: error instanceof Error ? error.message : String(error)
+        });
+      }, "onRetry")
+    }));
   }
 };
 _ts_decorate([
@@ -562,6 +584,9 @@ var AgentDepsFactory2 = class {
       ...this.options.toolTimeoutMs !== void 0 ? {
         toolTimeoutMs: this.options.toolTimeoutMs
       } : {},
+      ...this.options.toolTransientRetry !== void 0 ? {
+        toolTransientRetry: this.options.toolTransientRetry
+      } : {},
       ...followUpsCount !== void 0 ? {
         followUpsCount
       } : {},