@dudousxd/nestjs-agent 0.6.0 → 0.8.0

package/dist/durable/index.d.cts

@@ -19,11 +19,24 @@ interface DispatchedLlmInput extends LlmStepEnvelope {
      * wire-contract change once the durable runtime exposes the attempt.
      */
     runId: string;
+    /** The turn index within the run (`llm:<step>`) — the `llm.turn` span's `step` metadata. */
+    step: number;
     /** The stream target: `input.sinkRunId ?? ctx.runId` of the dispatching workflow. */
     sinkRunId: string;
     /** True for a sub-agent run — wrap the writer with {@link childSinkWriter} (no end/fail). */
     childSink: boolean;
 }
+/**
+ * Serializable input for the dispatched `tool` step: a {@link ToolStepEnvelope} plus the call
+ * identity the `tool.execution` span needs (`toolCallId`/`toolType`) — core's
+ * `AgentLoopHooks.dispatchTool` passes those on the separate `ToolCallRequest` argument, so the
+ * workflow folds them into the wire payload when it dispatches (same pattern as
+ * {@link DispatchedLlmInput}'s sink routing).
+ */
+interface DispatchedToolInput extends ToolStepEnvelope {
+    toolCallId: string;
+    toolType: 'read' | 'action';
+}
 /**
  * The two long steps `AgentRunWorkflow` dispatches as routed remote steps (`AgentRunSteps.llm` /
  * `AgentRunSteps.tool`) — the default under `durable: true`; `dispatchedSteps: false` runs them
@@ -47,7 +60,7 @@ declare class AgentRunSteps {
      * 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.
      */
-    tool(input: ToolStepEnvelope): Promise<unknown>;
+    tool(input: DispatchedToolInput): Promise<unknown>;
 }
 
 /**
@@ -130,4 +143,4 @@ declare function agentDurable(options: AgentModuleOptions): DynamicModule[];
  */
 declare const AGENT_DISPATCHED_STEPS: unique symbol;
 
-export { AGENT_DISPATCHED_STEPS, AgentDurableModule, AgentRunSteps, AgentRunWorkflow, type DispatchedLlmInput, DurableAgentRunner, agentDurable };
+export { AGENT_DISPATCHED_STEPS, AgentDurableModule, AgentRunSteps, AgentRunWorkflow, type DispatchedLlmInput, type DispatchedToolInput, DurableAgentRunner, agentDurable };

package/dist/durable/index.d.ts

@@ -19,11 +19,24 @@ interface DispatchedLlmInput extends LlmStepEnvelope {
      * wire-contract change once the durable runtime exposes the attempt.
      */
     runId: string;
+    /** The turn index within the run (`llm:<step>`) — the `llm.turn` span's `step` metadata. */
+    step: number;
     /** The stream target: `input.sinkRunId ?? ctx.runId` of the dispatching workflow. */
     sinkRunId: string;
     /** True for a sub-agent run — wrap the writer with {@link childSinkWriter} (no end/fail). */
     childSink: boolean;
 }
+/**
+ * Serializable input for the dispatched `tool` step: a {@link ToolStepEnvelope} plus the call
+ * identity the `tool.execution` span needs (`toolCallId`/`toolType`) — core's
+ * `AgentLoopHooks.dispatchTool` passes those on the separate `ToolCallRequest` argument, so the
+ * workflow folds them into the wire payload when it dispatches (same pattern as
+ * {@link DispatchedLlmInput}'s sink routing).
+ */
+interface DispatchedToolInput extends ToolStepEnvelope {
+    toolCallId: string;
+    toolType: 'read' | 'action';
+}
 /**
  * The two long steps `AgentRunWorkflow` dispatches as routed remote steps (`AgentRunSteps.llm` /
  * `AgentRunSteps.tool`) — the default under `durable: true`; `dispatchedSteps: false` runs them
@@ -47,7 +60,7 @@ declare class AgentRunSteps {
      * 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.
      */
-    tool(input: ToolStepEnvelope): Promise<unknown>;
+    tool(input: DispatchedToolInput): Promise<unknown>;
 }
 
 /**
@@ -130,4 +143,4 @@ declare function agentDurable(options: AgentModuleOptions): DynamicModule[];
  */
 declare const AGENT_DISPATCHED_STEPS: unique symbol;
 
-export { AGENT_DISPATCHED_STEPS, AgentDurableModule, AgentRunSteps, AgentRunWorkflow, type DispatchedLlmInput, DurableAgentRunner, agentDurable };
+export { AGENT_DISPATCHED_STEPS, AgentDurableModule, AgentRunSteps, AgentRunWorkflow, type DispatchedLlmInput, type DispatchedToolInput, DurableAgentRunner, agentDurable };

package/dist/durable/index.js

@@ -4,7 +4,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 // src/durable/agent-run.workflow.ts
 import { AGENT_DEPS_FACTORY as AGENT_DEPS_FACTORY2, AGENT_STORE, QuotaExceededError, publishAgentRunFailed, runAgentLoop } from "@dudousxd/nestjs-agent-core";
 import { Workflow } from "@dudousxd/nestjs-durable";
-import { ContinueAsNew, WorkflowSuspended } from "@dudousxd/nestjs-durable-core";
+import { isWorkflowControlFlowSignal } from "@dudousxd/nestjs-durable-core";
 import { Inject as Inject2, Injectable as Injectable2 } from "@nestjs/common";
 
 // src/agent-deps.ts
@@ -24,7 +24,7 @@ function childSinkWriter(writer) {
 __name(childSinkWriter, "childSinkWriter");
 
 // src/durable/agent-run.steps.ts
-import { AGENT_DEPS_FACTORY, withToolTimeout } from "@dudousxd/nestjs-agent-core";
+import { AGENT_DEPS_FACTORY, 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) {
@@ -63,12 +63,12 @@ var AgentRunSteps = class {
     const tools = await deps.registry.definitionsFor(input.actor, deps.rolesPolicy, deps.toolAllowList);
     const opened = await deps.sink.open(input.sinkRunId);
     const writer = input.childSink ? childSinkWriter(opened) : opened;
-    return deps.model.runTurn({
+    return traceLlmTurn(input.runId, input.step, () => deps.model.runTurn({
       system: input.system,
       messages: input.messages,
       tools,
       sink: writer
-    });
+    }));
   }
   /**
   * No retries — a tool may not be idempotent (a bare `@Step()` carries none, unlike `llm` above).
@@ -80,8 +80,14 @@ var AgentRunSteps = class {
     const ctx = {
       ...input.ctx
     };
-    const invocation = deps.registry.invoke(input.toolName, input.input, ctx, deps.rolesPolicy);
-    return input.timeoutMs !== void 0 ? withToolTimeout(invocation, input.timeoutMs, input.toolName) : invocation;
+    return traceToolExecution(input.ctx.runId, {
+      toolCallId: input.toolCallId,
+      toolName: input.toolName,
+      toolType: input.toolType
+    }, () => {
+      const invocation = deps.registry.invoke(input.toolName, input.input, ctx, deps.rolesPolicy);
+      return input.timeoutMs !== void 0 ? withToolTimeout(invocation, input.timeoutMs, input.toolName) : invocation;
+    });
   }
 };
 _ts_decorate([
@@ -98,7 +104,7 @@ _ts_decorate([
   Step(),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    typeof ToolStepEnvelope === "undefined" ? Object : ToolStepEnvelope
+    typeof DispatchedToolInput === "undefined" ? Object : DispatchedToolInput
   ]),
   _ts_metadata("design:returntype", Promise)
 ], AgentRunSteps.prototype, "tool", null);
@@ -159,8 +165,11 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
       openSink: /* @__PURE__ */ __name(async () => input.sinkRunId !== void 0 ? childSinkWriter(await deps.sink.open(sinkRunId)) : deps.sink.open(ctx.runId), "openSink"),
       awaitApproval: /* @__PURE__ */ __name((call) => ctx.waitForSignal(`tool:${ctx.runId}:${call.id}`), "awaitApproval"),
       step: /* @__PURE__ */ __name((name, fn) => ctx.localStep(name, fn), "step"),
-      // Dispatched-step suspends must escape the loop's tool catch — control flow, not a tool failure.
-      isControlFlowError: /* @__PURE__ */ __name((error) => error instanceof WorkflowSuspended || error instanceof ContinueAsNew, "isControlFlowError"),
+      // Dispatched-step suspends must escape the loop's tool catch — control flow, not a tool
+      // failure. Marker-based predicate, NOT instanceof: the signal's CLASS differs by runtime
+      // (engine in-process throws durable-core's WorkflowSuspended/ContinueAsNew; the BullMQ thin
+      // worker throws durable-worker's own Suspend), so only the Symbol.for marker is reliable.
+      isControlFlowError: /* @__PURE__ */ __name((error) => isWorkflowControlFlowSignal(error), "isControlFlowError"),
       runAgent: /* @__PURE__ */ __name(async (agentName, task) => {
         const subThreadId = await ctx.localStep(`subthread:${agentName}`, async () => {
           const thread = await this.store.createThread({
@@ -184,13 +193,23 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
       // execution. `sinkRunId`/`childSink` are sink routing this workflow already resolved above —
       // core's dispatchLlm signature stays sink-topology-agnostic, so we add them here, not in core.
       ...this.dispatchedSteps ? {
-        dispatchLlm: /* @__PURE__ */ __name((_index, envelope) => ctx.step(this.steps.llm, {
+        dispatchLlm: /* @__PURE__ */ __name((index, envelope) => ctx.step(this.steps.llm, {
           ...envelope,
           runId: ctx.runId,
+          step: index,
           sinkRunId,
           childSink: input.sinkRunId !== void 0
         }), "dispatchLlm"),
-        dispatchTool: /* @__PURE__ */ __name((_call, envelope) => ctx.step(this.steps.tool, envelope), "dispatchTool")
+        // Fold the call identity (`toolCallId`/`toolType`) into the wire payload — the handler
+        // emits the `tool.execution` span with it. Only read/action calls reach dispatchTool
+        // ('agent'-kind delegations branch to runAgent earlier in the loop), so anything that
+        // isn't 'action' is defensively 'read' — the same posture core takes for an
+        // unresolvable `kind`.
+        dispatchTool: /* @__PURE__ */ __name((call, envelope) => ctx.step(this.steps.tool, {
+          ...envelope,
+          toolCallId: call.id,
+          toolType: call.kind === "action" ? "action" : "read"
+        }), "dispatchTool")
       } : {}
     };
     try {
@@ -201,7 +220,7 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
       await ctx.localStep("deactivate", () => this.store.setActiveStream(input.threadId, null));
       return result;
     } catch (error) {
-      if (error instanceof WorkflowSuspended || error instanceof ContinueAsNew) {
+      if (isWorkflowControlFlowSignal(error)) {
         throw error;
       }
       const message = error instanceof Error ? error.message : String(error);
@@ -248,7 +267,7 @@ AgentRunWorkflow = _ts_decorate2([
 // src/durable/durable-agent-runner.ts
 import { randomUUID } from "node:crypto";
 import { WorkflowService } from "@dudousxd/nestjs-durable";
-import { WorkflowSuspended as WorkflowSuspended2 } from "@dudousxd/nestjs-durable-core";
+import { isWorkflowControlFlowSignal as isWorkflowControlFlowSignal2 } from "@dudousxd/nestjs-durable-core";
 import { Injectable as Injectable3 } from "@nestjs/common";
 function _ts_decorate3(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -278,7 +297,7 @@ var DurableAgentRunner = class {
     try {
       await this.workflows.start(AgentRunWorkflow, stamped, runId);
     } catch (error) {
-      if (!(error instanceof WorkflowSuspended2)) {
+      if (!isWorkflowControlFlowSignal2(error)) {
         throw error;
       }
     }