@dudousxd/nestjs-agent 0.7.0 → 0.8.1

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

@@ -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);
@@ -187,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 {