@dudousxd/nestjs-agent 1.16.0 → 1.17.0

package/dist/durable/index.d.cts

@@ -23,6 +23,7 @@ declare class AgentRunWorkflow {
     private readonly store;
     private readonly runs?;
     private readonly queue?;
+    private readonly logger;
     constructor(factory: AgentDepsFactory, store: AgentStore, runs?: RunGateway | undefined, queue?: ChatQueueService | undefined);
     /**
      * Move the thread past this settling turn — to the next queued message, started here as a
@@ -122,6 +123,7 @@ declare class AgentRunSteps {
      * across however many turns/retries it takes.
      */
     llm(input: DispatchedLlmInput): Promise<BufferedModelTurnResult>;
+    private runLlm;
     /**
      * 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
@@ -133,6 +135,7 @@ declare class AgentRunSteps {
      * ATTEMPT, so a retried invocation gets its own fresh timeout window.
      */
     tool(input: DispatchedToolInput): Promise<unknown>;
+    private runTool;
 }
 
 /**

package/dist/durable/index.d.ts

@@ -23,6 +23,7 @@ declare class AgentRunWorkflow {
     private readonly store;
     private readonly runs?;
     private readonly queue?;
+    private readonly logger;
     constructor(factory: AgentDepsFactory, store: AgentStore, runs?: RunGateway | undefined, queue?: ChatQueueService | undefined);
     /**
      * Move the thread past this settling turn — to the next queued message, started here as a
@@ -122,6 +123,7 @@ declare class AgentRunSteps {
      * across however many turns/retries it takes.
      */
     llm(input: DispatchedLlmInput): Promise<BufferedModelTurnResult>;
+    private runLlm;
     /**
      * 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
@@ -133,6 +135,7 @@ declare class AgentRunSteps {
      * ATTEMPT, so a retried invocation gets its own fresh timeout window.
      */
     tool(input: DispatchedToolInput): Promise<unknown>;
+    private runTool;
 }
 
 /**

package/dist/durable/index.js

@@ -2,10 +2,10 @@ var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/durable/agent-run.workflow.ts
-import { AGENT_DEPS_FACTORY as AGENT_DEPS_FACTORY2, AGENT_STORE as AGENT_STORE2, RunCancelledError, agentFailureCode, encodeStreamEvent as encodeStreamEvent3, isReplayIntegrityError, publishAgentRunFailed, releaseThreadRun, runAgentLoop, settleAll, settleUnsettledDelegation } from "@dudousxd/nestjs-agent-core";
+import { AGENT_DEPS_FACTORY as AGENT_DEPS_FACTORY2, AGENT_STORE as AGENT_STORE2, RUN_ENDED_BEFORE_TOOL_CALL, RunCancelledError, agentFailureCode, encodeStreamEvent as encodeStreamEvent3, isReplayIntegrityError, publishAgentRunFailed, releaseThreadRun, runAgentLoop, settleAll, settleDeadRun, settleUnsettledDelegation, streamFailure } from "@dudousxd/nestjs-agent-core";
 import { RUN_GATEWAY, Workflow } from "@dudousxd/nestjs-durable";
 import { isWorkflowControlFlowSignal } from "@dudousxd/nestjs-durable-core";
-import { Inject as Inject3, Injectable as Injectable3, Optional as Optional2 } from "@nestjs/common";
+import { Inject as Inject3, Injectable as Injectable3, Logger as Logger2, Optional as Optional2 } from "@nestjs/common";
 
 // src/agent-deps.ts
 function utcDay(date = /* @__PURE__ */ new Date()) {
@@ -451,9 +451,22 @@ function queueFrame(items, paused, started) {
 __name(queueFrame, "queueFrame");
 
 // src/durable/agent-run.steps.ts
-import { AGENT_DEPS_FACTORY, createFrameBuffer, createUiCollector, encodeStreamEvent as encodeStreamEvent2, invokeWithTransientRetry, observeTurnFrames, publishAgentToolRetry, stampToolKinds, traceLlmTurn, traceToolExecution, withAskTool, withMemoryTool, withSkillTool, withToolTimeout, withTurnFrames, wrapToolStepOutput } from "@dudousxd/nestjs-agent-core";
+import { AGENT_DEPS_FACTORY, createFrameBuffer, createUiCollector, encodeStreamEvent as encodeStreamEvent2, invokeWithTransientRetry, observeTurnFrames, publishAgentToolRetry, stampToolKinds, toolCallContext, traceLlmTurn, traceToolExecution, withAskTool, withMemoryTool, withSkillTool, withToolTimeout, withTurnFrames, wrapToolStepOutput } from "@dudousxd/nestjs-agent-core";
 import { Step } from "@dudousxd/nestjs-durable";
 import { Inject as Inject2, Injectable as Injectable2 } from "@nestjs/common";
+
+// src/durable/outside-workflow-ctx.ts
+import { runInWorkflowCtx } from "@dudousxd/nestjs-durable-core";
+function outsideWorkflowCtx(fn) {
+  return runInWorkflowCtx(void 0, fn);
+}
+__name(outsideWorkflowCtx, "outsideWorkflowCtx");
+function stepOf(ctx) {
+  return (name, fn, ...rest) => ctx.localStep(name, (...args) => outsideWorkflowCtx(() => fn(...args)), ...rest);
+}
+__name(stepOf, "stepOf");
+
+// src/durable/agent-run.steps.ts
 function _ts_decorate2(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
@@ -494,7 +507,10 @@ var AgentRunSteps = class {
   * double-writes. NEVER call `writer.end()`/`fail()` here: the workflow owns the stream's lifecycle,
   * across however many turns/retries it takes.
   */
-  async llm(input) {
+  llm(input) {
+    return outsideWorkflowCtx(() => this.runLlm(input));
+  }
+  async runLlm(input) {
     const deps = this.factory.forAgent(input.agentName);
     const tools = withMemoryTool({
       tools: withSkillTool({
@@ -547,7 +563,10 @@ var AgentRunSteps = class {
   * 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) {
+  tool(input) {
+    return outsideWorkflowCtx(() => this.runTool(input));
+  }
+  async runTool(input) {
     const deps = this.factory.forAgent(input.ctx.agentName);
     if (deps.registry.spec(input.toolName)?.kind === "action" && input.toolType !== "action") {
       throw new Error(`tool "${input.toolName}" is an action tool but was dispatched without approval: the dispatching process resolved its kind against a registry that does not have it`);
@@ -559,7 +578,7 @@ var AgentRunSteps = class {
       await (await opened).write(encodeStreamEvent2(event));
     });
     const ctx = {
-      ...input.ctx,
+      ...toolCallContext(input.ctx, input.toolCallId),
       emitUi: ui.emit
     };
     const localClassify = deps.toolTransientRetry !== false ? deps.toolTransientRetry?.classify : void 0;
@@ -599,7 +618,7 @@ _ts_decorate2([
   _ts_metadata2("design:paramtypes", [
     typeof DispatchedLlmInput === "undefined" ? Object : DispatchedLlmInput
   ]),
-  _ts_metadata2("design:returntype", Promise)
+  _ts_metadata2("design:returntype", typeof Promise === "undefined" ? Object : Promise)
 ], AgentRunSteps.prototype, "llm", null);
 _ts_decorate2([
   Step(),
@@ -607,7 +626,7 @@ _ts_decorate2([
   _ts_metadata2("design:paramtypes", [
     typeof DispatchedToolInput === "undefined" ? Object : DispatchedToolInput
   ]),
-  _ts_metadata2("design:returntype", Promise)
+  _ts_metadata2("design:returntype", typeof Promise === "undefined" ? Object : Promise)
 ], AgentRunSteps.prototype, "tool", null);
 AgentRunSteps = _ts_decorate2([
   Injectable2(),
@@ -653,6 +672,7 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
   store;
   runs;
   queue;
+  logger = new Logger2(_AgentRunWorkflow.name);
   constructor(factory, store, runs, queue) {
     this.factory = factory;
     this.store = store;
@@ -677,7 +697,7 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
     if (!await ctx.patched("agent:chat-queue")) {
       return void 0;
     }
-    const plan = await ctx.localStep(`queue:${outcome}`, async () => {
+    const plan = await stepOf(ctx)(`queue:${outcome}`, async () => {
       try {
         const settled = outcome === "completed" && await this.isCancelled(ctx.runId) ? "cancelled" : outcome;
         return await queue.plan({
@@ -704,7 +724,7 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
         throw failure;
       }
       const reason = failure instanceof Error ? failure.message : String(failure);
-      return ctx.localStep("queue:restore", async () => {
+      return stepOf(ctx)("queue:restore", async () => {
         await queue.restore(input.threadId, next, "start_failed", reason);
         return queue.pausedFrame(input.threadId);
       });
@@ -746,7 +766,7 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
     if (delivery === void 0) {
       return;
     }
-    await ctx.localStep("deliver:detached:unsettled", () => settleUnsettledDelegation({
+    await stepOf(ctx)("deliver:detached:unsettled", () => settleUnsettledDelegation({
       store: this.store,
       delivery,
       agent: input.agentName ?? "default",
@@ -762,7 +782,7 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
     const deps = this.factory.forAgent(input.agentName);
     const dispatchSteps = await ctx.patched("agent:dispatched-steps");
     if (input.sinkRunId !== void 0 || input.deliverTo !== void 0) {
-      await ctx.localStep("activate", () => this.store.setActiveStream(input.threadId, ctx.runId));
+      await stepOf(ctx)("activate", () => this.store.setActiveStream(input.threadId, ctx.runId));
     }
     const sinkRunId = input.sinkRunId ?? ctx.runId;
     const chainBelow = [
@@ -812,7 +832,9 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
       // question set and an approval reach a parked run through one path, and the HTTP surface that
       // settles either one is the same `POST /agent/tool-call/*` family.
       awaitAnswers: /* @__PURE__ */ __name((request) => ctx.waitForSignal(`tool:${ctx.runId}:${request.id}`), "awaitAnswers"),
-      step: /* @__PURE__ */ __name((name, fn) => ctx.localStep(name, fn), "step"),
+      // Bodies run outside the ambient workflow ctx, so nothing the application does in there can
+      // take a position in this run's journal (see `outsideWorkflowCtx`).
+      step: /* @__PURE__ */ __name((name, fn) => stepOf(ctx)(name, fn), "step"),
       // Both durable step primitives take their checkpoint position on the CALL, before their first
       // await, so launching a batch in one tick — what `settleAll` does — fixes the block of
       // positions in call order however the tools then settle. `ctx.patched` keeps a run that
@@ -826,7 +848,7 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
       // 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 subThreadId = await stepOf(ctx)(`subthread:${agentName}`, async () => {
           const thread = await this.store.createThread({
             actor: input.actor,
             transient: true
@@ -857,7 +879,7 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
       //   - `deliverTo` instead. The parent's tool result is a receipt, so the answer needs an
       //     address of its own, and by the time it exists nobody is holding one.
       startAgent: /* @__PURE__ */ __name(async ({ agentName, task, toolCallId: toolCallId2 }) => {
-        const subThreadId = await ctx.localStep(`subthread:${agentName}`, async () => {
+        const subThreadId = await stepOf(ctx)(`subthread:${agentName}`, async () => {
           const thread = await this.store.createThread({
             actor: input.actor,
             transient: true
@@ -915,46 +937,58 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
         ...deps,
         day
       }, input, hooks);
-      await ctx.localStep("deactivate", () => releaseThreadRun(this.store, input.threadId, ctx.runId));
+      await stepOf(ctx)("deactivate", () => releaseThreadRun(this.store, input.threadId, ctx.runId));
       return result;
     } catch (error) {
       if (isWorkflowControlFlowSignal(error)) {
         throw error;
       }
       if (error instanceof RunCancelledError) {
-        await ctx.localStep("deactivate", () => releaseThreadRun(this.store, input.threadId, ctx.runId));
+        await stepOf(ctx)("deactivate", () => releaseThreadRun(this.store, input.threadId, ctx.runId));
         await this.settleDetachedParent(ctx, input, {
           status: "cancelled"
         });
         throw error;
       }
       if (isReplayIntegrityError(error)) {
-        const failure = {
-          code: "run_failed",
-          message: error.message
-        };
+        const detail = error.message;
+        const code2 = agentFailureCode(error);
+        this.logger.error(`agent run ${ctx.runId} failed (${code2}): ${detail}`);
         publishAgentRunFailed({
           runId: ctx.runId,
-          ...failure
+          code: code2,
+          message: detail
         });
-        await (await hooks.openSink()).fail(failure);
+        await settleDeadRun(this.store, {
+          runId: ctx.runId,
+          threadId: input.threadId,
+          failure: {
+            code: code2,
+            message: detail
+          }
+        });
+        await (await hooks.openSink()).fail(streamFailure(error));
         throw error;
       }
       const message = error instanceof Error ? error.message : String(error);
       const code = agentFailureCode(error);
+      this.logger.error(`agent run ${ctx.runId} failed (${code}): ${message}`);
       publishAgentRunFailed({
         runId: ctx.runId,
         code,
         message
       });
-      await ctx.localStep("persist:run:fail", () => this.store.recordRunEnd?.({
-        runId: ctx.runId,
-        status: "failed",
-        errorCode: code,
-        errorMessage: message
-      }) ?? Promise.resolve());
+      await stepOf(ctx)("persist:run:fail", async () => {
+        await this.store.recordRunEnd?.({
+          runId: ctx.runId,
+          status: "failed",
+          errorCode: code,
+          errorMessage: message
+        });
+        await Promise.resolve(this.store.failUnsettledToolCalls?.(ctx.runId, RUN_ENDED_BEFORE_TOOL_CALL)).catch(() => 0);
+      });
       const queueFrame2 = await this.advanceQueue(ctx, input, "failed", message);
-      await ctx.localStep("deactivate", () => releaseThreadRun(this.store, input.threadId, ctx.runId));
+      await stepOf(ctx)("deactivate", () => releaseThreadRun(this.store, input.threadId, ctx.runId));
       await this.settleDetachedParent(ctx, input, {
         status: "failed",
         error: message
@@ -963,10 +997,7 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
       if (queueFrame2 !== void 0) {
         await writer.write(encodeStreamEvent3(queueFrame2));
       }
-      await writer.fail({
-        code,
-        message
-      });
+      await writer.fail(streamFailure(error));
       throw error;
     }
   }
@@ -1000,7 +1031,7 @@ import { randomUUID } from "crypto";
 import { AGENT_SINK as AGENT_SINK2, AGENT_STORE as AGENT_STORE3, encodeStreamEvent as encodeStreamEvent4, releaseThreadRun as releaseThreadRun2 } from "@dudousxd/nestjs-agent-core";
 import { RUN_GATEWAY as RUN_GATEWAY2, WorkflowService } from "@dudousxd/nestjs-durable";
 import { isWorkflowControlFlowSignal as isWorkflowControlFlowSignal2 } from "@dudousxd/nestjs-durable-core";
-import { Inject as Inject4, Injectable as Injectable4, Logger as Logger2, Optional as Optional3 } from "@nestjs/common";
+import { Inject as Inject4, Injectable as Injectable4, Logger as Logger3, Optional as Optional3 } from "@nestjs/common";
 
 // src/in-process-sink.ts
 import { AgentStreamError } from "@dudousxd/nestjs-agent-core";
@@ -1117,7 +1148,7 @@ var DurableAgentRunner = class _DurableAgentRunner {
   store;
   sink;
   queue;
-  logger = new Logger2(_DurableAgentRunner.name);
+  logger = new Logger3(_DurableAgentRunner.name);
   constructor(workflows, runs, store, sink, queue) {
     this.workflows = workflows;
     this.runs = runs;
@@ -1343,7 +1374,7 @@ AgentDurableModule = _ts_decorate5([
 
 // src/agent.module.ts
 import { AGENT_ACTOR_RESOLVER as AGENT_ACTOR_RESOLVER13, AGENT_APPROVAL_PORT, AGENT_DEPS_FACTORY as AGENT_DEPS_FACTORY7, AGENT_DURABLE_RUNNER as AGENT_DURABLE_RUNNER2, AGENT_MEMORY as AGENT_MEMORY3, AGENT_MODEL as AGENT_MODEL2, AGENT_MODEL_CATALOG as AGENT_MODEL_CATALOG3, AGENT_OPTIONS as AGENT_OPTIONS7, AGENT_PROMPT_CONTRIBUTORS as AGENT_PROMPT_CONTRIBUTORS3, AGENT_QUOTA_PROVIDER as AGENT_QUOTA_PROVIDER3, AGENT_REGISTRY as AGENT_REGISTRY6, AGENT_ROLES_POLICY as AGENT_ROLES_POLICY2, AGENT_RUNNER as AGENT_RUNNER2, AGENT_SINK as AGENT_SINK4, AGENT_SKILLS as AGENT_SKILLS3, AGENT_SKILL_SOURCES as AGENT_SKILL_SOURCES2, AGENT_STORE as AGENT_STORE7, AGENT_TOOL_REGISTRY as AGENT_TOOL_REGISTRY3, AgentRegistry as AgentRegistry6, DefaultRolesPolicy, InMemoryAgentStore, ToolRegistry as ToolRegistry3 } from "@dudousxd/nestjs-agent-core";
-import { Global as Global2, Logger as Logger7, Module as Module2 } from "@nestjs/common";
+import { Global as Global2, Logger as Logger8, Module as Module2 } from "@nestjs/common";
 import { DiscoveryModule, ModulesContainer, RouterModule } from "@nestjs/core";
 
 // src/agent-deps.factory.ts
@@ -1605,8 +1636,28 @@ AgentDepsFactory2 = _ts_decorate6([
 ], AgentDepsFactory2);
 
 // src/agent.service.ts
-import { AGENT_ATTACHMENT_STAGING as AGENT_ATTACHMENT_STAGING2, AGENT_DEPS_FACTORY as AGENT_DEPS_FACTORY3, AGENT_MODEL_CATALOG, AGENT_OPTIONS as AGENT_OPTIONS3, AGENT_QUOTA_PROVIDER as AGENT_QUOTA_PROVIDER2, AGENT_RUNNER, AGENT_STORE as AGENT_STORE5, REQUESTER_APPROVER, findCatalogModel, mayDecideApproval, readElicitationQuestions, validateElicitationAnswer } from "@dudousxd/nestjs-agent-core";
-import { BadRequestException, ConflictException, ForbiddenException, GoneException, HttpException, HttpStatus, Inject as Inject6, Injectable as Injectable6, NotFoundException, NotImplementedException as NotImplementedException2, Optional as Optional5 } from "@nestjs/common";
+import { AGENT_ATTACHMENT_STAGING as AGENT_ATTACHMENT_STAGING2, AGENT_DEPS_FACTORY as AGENT_DEPS_FACTORY3, AGENT_MODEL_CATALOG, AGENT_OPTIONS as AGENT_OPTIONS3, AGENT_QUOTA_PROVIDER as AGENT_QUOTA_PROVIDER2, AGENT_RUNNER, AGENT_STORE as AGENT_STORE5, REQUESTER_APPROVER, findCatalogModel, mayDecideApproval, readElicitationQuestions, settleDeadRun as settleDeadRun2, validateElicitationAnswer } from "@dudousxd/nestjs-agent-core";
+import { BadRequestException, ConflictException as ConflictException2, ForbiddenException, GoneException, HttpException, HttpStatus, Inject as Inject6, Injectable as Injectable6, NotFoundException, NotImplementedException as NotImplementedException2, Optional as Optional5 } from "@nestjs/common";
+
+// src/run-not-active.exception.ts
+import { RUN_NOT_ACTIVE_CODE, RUN_NOT_ACTIVE_MESSAGE } from "@dudousxd/nestjs-agent-core";
+import { ConflictException } from "@nestjs/common";
+var RunNotActiveException = class extends ConflictException {
+  static {
+    __name(this, "RunNotActiveException");
+  }
+  runId;
+  code = RUN_NOT_ACTIVE_CODE;
+  constructor(runId) {
+    super({
+      statusCode: 409,
+      code: RUN_NOT_ACTIVE_CODE,
+      message: RUN_NOT_ACTIVE_MESSAGE
+    }), this.runId = runId;
+  }
+};
+
+// src/agent.service.ts
 function _ts_decorate7(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
@@ -1803,7 +1854,7 @@ var AgentService = class {
       };
     }
     await this.requireQueue().publish(result.threadId);
-    throw new ConflictException({
+    throw new ConflictException2({
       statusCode: 409,
       code: "run_active",
       message: `thread ${result.threadId} already has a turn running`
@@ -1863,6 +1914,11 @@ var AgentService = class {
     }
     const mode = params.mode ?? "auto";
     const { live, stale } = await queue.holder(threadId, this.runner);
+    if (stale !== null) {
+      await settleDeadRun2(this.store, {
+        runId: stale
+      });
+    }
     if (live === null && mode !== "queue") {
       const runId = crypto.randomUUID();
       if (await queue.queueStore().claimActiveStream(threadId, runId, stale !== null ? {
@@ -1875,7 +1931,7 @@ var AgentService = class {
       }
     }
     if (params.regenerate === true) {
-      throw new ConflictException({
+      throw new ConflictException2({
         statusCode: 409,
         code: "run_active",
         message: "cannot regenerate while a turn is running on this thread"
@@ -2223,8 +2279,29 @@ var AgentService = class {
   async signalToolCall(toolCallId2, reply) {
     await this.assertNotExpired(toolCallId2);
     const runId = await this.resolveRunForToolCall(toolCallId2);
+    await this.assertRunWaiting(runId);
     return this.runner.signal(runId, toolCallId2, reply);
   }
+  /**
+  * Refuse a decision addressed at a run that is over (`409 run_not_active`). The runtime would take
+  * the signal and buffer it for a run that never comes back — the person's "yes" is accepted, the
+  * card says so, and nothing runs. Settles the calls the dead run left awaiting a decision on the
+  * way out, so the card stops asking. A runner that cannot say whether a run is alive is taken at
+  * its word that it is, and so is one that fails to answer.
+  */
+  async assertRunWaiting(runId) {
+    if (typeof this.runner.isRunActive !== "function") {
+      return;
+    }
+    const active = await this.runner.isRunActive(runId).catch(() => true);
+    if (active) {
+      return;
+    }
+    await settleDeadRun2(this.store, {
+      runId
+    });
+    throw new RunNotActiveException(runId);
+  }
   async cancel(actor, runId) {
     await this.assertOwnsActiveStream(actor, runId);
     return this.runner.cancel(runId);
@@ -2908,7 +2985,7 @@ AttachmentsController = _ts_decorate10([
 ], AttachmentsController);
 
 // src/controller/chat.controller.ts
-import { AGENT_ACTOR_RESOLVER as AGENT_ACTOR_RESOLVER2, AgentStreamError as AgentStreamError2 } from "@dudousxd/nestjs-agent-core";
+import { AGENT_ACTOR_RESOLVER as AGENT_ACTOR_RESOLVER2, AgentStreamError as AgentStreamError2, streamFailure as streamFailure2 } from "@dudousxd/nestjs-agent-core";
 import { BadRequestException as BadRequestException3, Body, Controller as Controller3, Get as Get3, Inject as Inject9, Param, Post as Post2, Query, Req as Req2, Res } from "@nestjs/common";
 function _ts_decorate11(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -3104,10 +3181,7 @@ data: ${line}
       const payload = error instanceof AgentStreamError2 ? {
         code: error.code,
         message: error.message
-      } : {
-        code: "run_failed",
-        message: error instanceof Error ? error.message : "stream error"
-      };
+      } : streamFailure2(error);
       res.write(`event: error
 data: ${JSON.stringify(payload)}
 
@@ -4432,7 +4506,7 @@ ToolsController = _ts_decorate21([
 
 // src/discovery/agent-discovery.service.ts
 import { AGENT_PROMPT_CONTRIBUTORS as AGENT_PROMPT_CONTRIBUTORS2, AGENT_REGISTRY as AGENT_REGISTRY4, AgentRegistry as AgentRegistry5 } from "@dudousxd/nestjs-agent-core";
-import { Inject as Inject20, Injectable as Injectable8, Logger as Logger3 } from "@nestjs/common";
+import { Inject as Inject20, Injectable as Injectable8, Logger as Logger4 } from "@nestjs/common";
 import { DiscoveryService, MetadataScanner } from "@nestjs/core";
 
 // src/decorator/agent.decorator.ts
@@ -4483,7 +4557,7 @@ var AgentDiscoveryService = class _AgentDiscoveryService {
   scanner;
   registry;
   contributors;
-  logger = new Logger3(_AgentDiscoveryService.name);
+  logger = new Logger4(_AgentDiscoveryService.name);
   constructor(discovery, scanner, registry, contributors) {
     this.discovery = discovery;
     this.scanner = scanner;
@@ -4616,7 +4690,7 @@ AgentDiscoveryService = _ts_decorate22([
 
 // src/discovery/ai-tool-discovery.service.ts
 import { AGENT_OPTIONS as AGENT_OPTIONS6, AGENT_REGISTRY as AGENT_REGISTRY5, AGENT_TOOL_REGISTRY as AGENT_TOOL_REGISTRY2, normalizeDelegation as normalizeDelegation2 } from "@dudousxd/nestjs-agent-core";
-import { Inject as Inject21, Injectable as Injectable9, Logger as Logger4 } from "@nestjs/common";
+import { Inject as Inject21, Injectable as Injectable9, Logger as Logger5 } from "@nestjs/common";
 import { DiscoveryService as DiscoveryService2 } from "@nestjs/core";
 import { z } from "zod";
 
@@ -4670,7 +4744,7 @@ var AiToolDiscoveryService = class _AiToolDiscoveryService {
   registry;
   agents;
   options;
-  logger = new Logger4(_AiToolDiscoveryService.name);
+  logger = new Logger5(_AiToolDiscoveryService.name);
   constructor(discovery, registry, agents, options) {
     this.discovery = discovery;
     this.registry = registry;
@@ -4821,7 +4895,7 @@ AiToolDiscoveryService = _ts_decorate23([
 
 // src/discovery/skill-discovery.service.ts
 import { AGENT_SKILL_SOURCES } from "@dudousxd/nestjs-agent-core";
-import { Inject as Inject22, Injectable as Injectable10, Logger as Logger5 } from "@nestjs/common";
+import { Inject as Inject22, Injectable as Injectable10, Logger as Logger6 } from "@nestjs/common";
 import { DiscoveryService as DiscoveryService3 } from "@nestjs/core";
 
 // src/decorator/skill.decorator.ts
@@ -4870,7 +4944,7 @@ var SkillDiscoveryService = class _SkillDiscoveryService {
   }
   discovery;
   declared;
-  logger = new Logger5(_SkillDiscoveryService.name);
+  logger = new Logger6(_SkillDiscoveryService.name);
   constructor(discovery, declared) {
     this.discovery = discovery;
     this.declared = declared;
@@ -4980,8 +5054,8 @@ var LedgerQuotaProvider = class {
 };
 
 // src/runner/inline-agent-runner.ts
-import { AGENT_DEPS_FACTORY as AGENT_DEPS_FACTORY6, AGENT_STORE as AGENT_STORE6, RunCancelledError as RunCancelledError2, agentFailureCode as agentFailureCode2, encodeStreamEvent as encodeStreamEvent5, publishAgentRunFailed as publishAgentRunFailed2, releaseThreadRun as releaseThreadRun3, runAgentLoop as runAgentLoop2, settleAll as settleAll2, settleUnsettledDelegation as settleUnsettledDelegation2 } from "@dudousxd/nestjs-agent-core";
-import { Inject as Inject23, Injectable as Injectable11, Logger as Logger6, Optional as Optional10 } from "@nestjs/common";
+import { AGENT_DEPS_FACTORY as AGENT_DEPS_FACTORY6, AGENT_STORE as AGENT_STORE6, RUN_ENDED_BEFORE_TOOL_CALL as RUN_ENDED_BEFORE_TOOL_CALL2, RunCancelledError as RunCancelledError2, agentFailureCode as agentFailureCode2, encodeStreamEvent as encodeStreamEvent5, publishAgentRunFailed as publishAgentRunFailed2, releaseThreadRun as releaseThreadRun3, runAgentLoop as runAgentLoop2, settleAll as settleAll2, settleUnsettledDelegation as settleUnsettledDelegation2, streamFailure as streamFailure3 } from "@dudousxd/nestjs-agent-core";
+import { Inject as Inject23, Injectable as Injectable11, Logger as Logger7, Optional as Optional10 } from "@nestjs/common";
 function _ts_decorate25(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
@@ -5015,7 +5089,7 @@ var InlineAgentRunner = class _InlineAgentRunner {
   factory;
   store;
   queue;
-  logger = new Logger6(_InlineAgentRunner.name);
+  logger = new Logger7(_InlineAgentRunner.name);
   pending = /* @__PURE__ */ new Map();
   /**
   * Runs someone has asked to stop. In-process, like `pending`, and for the same reason: this runner
@@ -5035,7 +5109,15 @@ var InlineAgentRunner = class _InlineAgentRunner {
   * that was running it is gone (a restart), and a thread it still holds is a stale claim.
   */
   async isRunActive(runId) {
-    return this.live.has(runId);
+    if (this.live.has(runId)) {
+      return true;
+    }
+    for (const key of this.pending.keys()) {
+      if (key.startsWith(`${runId}:`)) {
+        return true;
+      }
+    }
+    return false;
   }
   async start(input, options = {}) {
     const runId = options.runId ?? crypto.randomUUID();
@@ -5078,13 +5160,11 @@ var InlineAgentRunner = class _InlineAgentRunner {
         errorCode: code,
         errorMessage: message
       });
+      await Promise.resolve(this.store.failUnsettledToolCalls?.(runId, RUN_ENDED_BEFORE_TOOL_CALL2)).catch(() => 0);
       const writer = await deps.sink.open(runId);
       await this.settleQueue(writer, input, runId, "failed", message);
       await releaseThreadRun3(this.store, input.threadId, runId);
-      await writer.fail({
-        code,
-        message
-      });
+      await writer.fail(streamFailure3(error));
     }).finally(() => {
       this.cancelled.delete(runId);
       this.live.delete(runId);
@@ -5358,6 +5438,7 @@ var InlineAgentRunner = class _InlineAgentRunner {
           errorMessage: message
         }
       });
+      await Promise.resolve(this.store.failUnsettledToolCalls?.(runId, RUN_ENDED_BEFORE_TOOL_CALL2)).catch(() => 0);
       await settleUnsettledDelegation2({
         store: this.store,
         delivery: deliverTo,
@@ -5522,7 +5603,7 @@ function _ts_decorate26(decorators, target, key, desc) {
 }
 __name(_ts_decorate26, "_ts_decorate");
 var DEFAULT_PATH = "agent";
-var logger = new Logger7("AgentModule");
+var logger = new Logger8("AgentModule");
 function externalStoreWrapper(modules) {
   for (const module of modules.values()) {
     if (module.metatype === AgentModule) continue;