@dudousxd/nestjs-agent 0.7.0 → 0.8.0

package/dist/durable/index.cjs

@@ -92,12 +92,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 (0, import_nestjs_agent_core.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).
@@ -109,8 +109,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 ? (0, import_nestjs_agent_core.withToolTimeout)(invocation, input.timeoutMs, input.toolName) : invocation;
+    return (0, import_nestjs_agent_core.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 ? (0, import_nestjs_agent_core.withToolTimeout)(invocation, input.timeoutMs, input.toolName) : invocation;
+    });
   }
 };
 _ts_decorate([
@@ -127,7 +133,7 @@ _ts_decorate([
   (0, import_nestjs_durable.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);
@@ -216,13 +222,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 {