@dudousxd/nestjs-agent 0.6.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);
@@ -188,8 +194,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 import_nestjs_durable_core.WorkflowSuspended || error instanceof import_nestjs_durable_core.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) => (0, import_nestjs_durable_core.isWorkflowControlFlowSignal)(error), "isControlFlowError"),
       runAgent: /* @__PURE__ */ __name(async (agentName, task) => {
         const subThreadId = await ctx.localStep(`subthread:${agentName}`, async () => {
           const thread = await this.store.createThread({
@@ -213,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 {
@@ -230,7 +249,7 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
       await ctx.localStep("deactivate", () => this.store.setActiveStream(input.threadId, null));
       return result;
     } catch (error) {
-      if (error instanceof import_nestjs_durable_core.WorkflowSuspended || error instanceof import_nestjs_durable_core.ContinueAsNew) {
+      if ((0, import_nestjs_durable_core.isWorkflowControlFlowSignal)(error)) {
         throw error;
       }
       const message = error instanceof Error ? error.message : String(error);
@@ -307,7 +326,7 @@ var DurableAgentRunner = class {
     try {
       await this.workflows.start(AgentRunWorkflow, stamped, runId);
     } catch (error) {
-      if (!(error instanceof import_nestjs_durable_core2.WorkflowSuspended)) {
+      if (!(0, import_nestjs_durable_core2.isWorkflowControlFlowSignal)(error)) {
         throw error;
       }
     }