@dudousxd/nestjs-agent 0.1.0

package/dist/durable/index.cjs

@@ -0,0 +1,1590 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/durable/index.ts
+var durable_exports = {};
+__export(durable_exports, {
+  AgentDurableModule: () => AgentDurableModule,
+  AgentRunWorkflow: () => AgentRunWorkflow,
+  DurableAgentRunner: () => DurableAgentRunner,
+  agentDurable: () => agentDurable
+});
+module.exports = __toCommonJS(durable_exports);
+
+// src/durable/agent-run.workflow.ts
+var import_nestjs_agent_core = require("@dudousxd/nestjs-agent-core");
+var import_nestjs_durable = require("@dudousxd/nestjs-durable");
+var import_nestjs_durable_core = require("@dudousxd/nestjs-durable-core");
+var import_common = require("@nestjs/common");
+
+// src/agent-deps.ts
+function utcDay(date = /* @__PURE__ */ new Date()) {
+  return date.toISOString().slice(0, 10);
+}
+__name(utcDay, "utcDay");
+function childSinkWriter(writer) {
+  return {
+    write: /* @__PURE__ */ __name((chunk) => writer.write(chunk), "write"),
+    end: /* @__PURE__ */ __name(async () => {
+    }, "end"),
+    fail: /* @__PURE__ */ __name(async () => {
+    }, "fail")
+  };
+}
+__name(childSinkWriter, "childSinkWriter");
+
+// src/durable/agent-run.workflow.ts
+function _ts_decorate(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") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+var AgentRunWorkflow = class _AgentRunWorkflow {
+  static {
+    __name(this, "AgentRunWorkflow");
+  }
+  factory;
+  store;
+  constructor(factory, store) {
+    this.factory = factory;
+    this.store = store;
+  }
+  async run(ctx, input) {
+    const day = input.day ?? utcDay();
+    const deps = this.factory.forAgent(input.agentName);
+    if (input.sinkRunId !== void 0) {
+      await ctx.step("activate", () => this.store.setActiveStream(input.threadId, ctx.runId));
+    }
+    const sinkRunId = input.sinkRunId ?? ctx.runId;
+    const hooks = {
+      runId: ctx.runId,
+      // A child forwards into the top-level sink but must not end/fail it (the top-level run owns it).
+      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.step(name, fn), "step"),
+      runAgent: /* @__PURE__ */ __name(async (agentName, task) => {
+        const subThreadId = await ctx.step(`subthread:${agentName}`, async () => {
+          const thread = await this.store.createThread({
+            actor: input.actor,
+            persona: "default",
+            transient: true
+          });
+          return thread.id;
+        });
+        return ctx.child(_AgentRunWorkflow, {
+          agentName,
+          threadId: subThreadId,
+          actor: input.actor,
+          userText: task,
+          day,
+          delegationDepth: (input.delegationDepth ?? 0) + 1,
+          sinkRunId
+        });
+      }, "runAgent")
+    };
+    try {
+      return await (0, import_nestjs_agent_core.runAgentLoop)({
+        ...deps,
+        day
+      }, input, hooks);
+    } catch (error) {
+      if (error instanceof import_nestjs_durable_core.WorkflowSuspended || error instanceof import_nestjs_durable_core.ContinueAsNew) {
+        throw error;
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      const code = error instanceof import_nestjs_agent_core.QuotaExceededError ? "quota_exceeded" : "run_failed";
+      (0, import_nestjs_agent_core.publishAgentRunFailed)({
+        runId: ctx.runId,
+        code,
+        message
+      });
+      const writer = await hooks.openSink();
+      await writer.fail({
+        code,
+        message
+      });
+      throw error;
+    }
+  }
+};
+AgentRunWorkflow = _ts_decorate([
+  (0, import_common.Injectable)(),
+  (0, import_nestjs_durable.Workflow)({
+    name: "agent.run",
+    version: "1"
+  }),
+  _ts_param(0, (0, import_common.Inject)(import_nestjs_agent_core.AGENT_DEPS_FACTORY)),
+  _ts_param(1, (0, import_common.Inject)(import_nestjs_agent_core.AGENT_STORE)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof AgentDepsFactory === "undefined" ? Object : AgentDepsFactory,
+    typeof AgentStore === "undefined" ? Object : AgentStore
+  ])
+], AgentRunWorkflow);
+
+// src/durable/durable-agent-runner.ts
+var import_nestjs_durable2 = require("@dudousxd/nestjs-durable");
+var import_common2 = require("@nestjs/common");
+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") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata2, "_ts_metadata");
+var DurableAgentRunner = class {
+  static {
+    __name(this, "DurableAgentRunner");
+  }
+  workflows;
+  constructor(workflows) {
+    this.workflows = workflows;
+  }
+  async start(input) {
+    const stamped = {
+      ...input,
+      day: input.day ?? utcDay()
+    };
+    const result = await this.workflows.start(AgentRunWorkflow, stamped);
+    return {
+      runId: result.runId
+    };
+  }
+  async signal(runId, toolCallId, decision) {
+    await this.workflows.signal(`tool:${runId}:${toolCallId}`, decision);
+  }
+  async cancel(_runId) {
+    await Promise.resolve();
+  }
+};
+DurableAgentRunner = _ts_decorate2([
+  (0, import_common2.Injectable)(),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof import_nestjs_durable2.WorkflowService === "undefined" ? Object : import_nestjs_durable2.WorkflowService
+  ])
+], DurableAgentRunner);
+
+// src/durable/agent-durable.module.ts
+var import_nestjs_agent_core2 = require("@dudousxd/nestjs-agent-core");
+var import_common3 = require("@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;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate3, "_ts_decorate");
+var AgentDurableModule = class _AgentDurableModule {
+  static {
+    __name(this, "AgentDurableModule");
+  }
+  /**
+  * The dynamic form used by the `agentDurable` helper. The module needs no configuration of its
+  * own (its providers come from the decorator above), so this just yields the module reference —
+  * importing `AgentDurableModule` directly stays equivalent.
+  */
+  static forRoot() {
+    return {
+      module: _AgentDurableModule,
+      global: true
+    };
+  }
+};
+AgentDurableModule = _ts_decorate3([
+  (0, import_common3.Global)(),
+  (0, import_common3.Module)({
+    providers: [
+      AgentRunWorkflow,
+      DurableAgentRunner,
+      {
+        provide: import_nestjs_agent_core2.AGENT_DURABLE_RUNNER,
+        useExisting: DurableAgentRunner
+      }
+    ],
+    exports: [
+      import_nestjs_agent_core2.AGENT_DURABLE_RUNNER,
+      AgentRunWorkflow
+    ]
+  })
+], AgentDurableModule);
+
+// src/agent.module.ts
+var import_nestjs_agent_core13 = require("@dudousxd/nestjs-agent-core");
+var import_common12 = require("@nestjs/common");
+var import_core2 = require("@nestjs/core");
+
+// src/agent-deps.factory.ts
+var import_nestjs_agent_core3 = require("@dudousxd/nestjs-agent-core");
+var import_nestjs_agent_core4 = require("@dudousxd/nestjs-agent-core");
+var import_common4 = require("@nestjs/common");
+function _ts_decorate4(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") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate4, "_ts_decorate");
+function _ts_metadata3(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata3, "_ts_metadata");
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_ts_param");
+function delegateToolName(target) {
+  return `ask_${target.replace(/[^a-zA-Z0-9]+/g, "_")}`;
+}
+__name(delegateToolName, "delegateToolName");
+var AgentDepsFactory2 = class {
+  static {
+    __name(this, "AgentDepsFactory");
+  }
+  options;
+  model;
+  store;
+  sink;
+  rolesPolicy;
+  registry;
+  agents;
+  quota;
+  constructor(options, model, store, sink, rolesPolicy, registry, agents, quota) {
+    this.options = options;
+    this.model = model;
+    this.store = store;
+    this.sink = sink;
+    this.rolesPolicy = rolesPolicy;
+    this.registry = registry;
+    this.agents = agents;
+    this.quota = quota;
+  }
+  defaultAgentName() {
+    return this.options.defaultAgent?.name ?? "default";
+  }
+  effectiveTools(definition) {
+    if (definition === void 0) {
+      return void 0;
+    }
+    const delegated = (definition.delegatesTo ?? []).map(delegateToolName);
+    if (definition.tools === void 0 && delegated.length === 0) {
+      return void 0;
+    }
+    return [
+      ...definition.tools ?? [],
+      ...delegated
+    ];
+  }
+  forAgent(agentName) {
+    const name = agentName ?? this.defaultAgentName();
+    const definition = this.agents.get(name);
+    const personas = /* @__PURE__ */ new Map();
+    for (const persona of definition?.personas ?? []) {
+      personas.set(persona.id, persona);
+    }
+    const toolAllowList = this.effectiveTools(definition);
+    const followUpsCount = this.followUpsCount();
+    const retrieval = this.options.retrieval;
+    return {
+      model: this.model,
+      store: this.store,
+      sink: this.sink,
+      rolesPolicy: this.rolesPolicy,
+      registry: this.registry,
+      systemPrompt: definition?.systemPrompt ?? "You are a helpful assistant.",
+      maxSteps: definition?.maxSteps ?? 8,
+      personas,
+      defaultPersona: definition?.defaultPersona ?? "default",
+      ...definition?.modelId !== void 0 ? {
+        modelId: definition.modelId
+      } : {},
+      ...this.quota !== void 0 ? {
+        quota: this.quota
+      } : {},
+      ...toolAllowList !== void 0 ? {
+        toolAllowList
+      } : {},
+      ...this.options.toolTimeoutMs !== void 0 ? {
+        toolTimeoutMs: this.options.toolTimeoutMs
+      } : {},
+      ...followUpsCount !== void 0 ? {
+        followUpsCount
+      } : {},
+      ...retrieval?.mode === "inject" ? {
+        retriever: retrieval.retriever,
+        ...retrieval.topK !== void 0 ? {
+          retrievalTopK: retrieval.topK
+        } : {}
+      } : {}
+    };
+  }
+  /** Normalize the `followUps` option (`true` → 3, `{ count }` → count) to a number, or undefined. */
+  followUpsCount() {
+    const followUps = this.options.followUps;
+    if (followUps === true) {
+      return 3;
+    }
+    if (typeof followUps === "object") {
+      return followUps.count;
+    }
+    return void 0;
+  }
+};
+AgentDepsFactory2 = _ts_decorate4([
+  (0, import_common4.Injectable)(),
+  _ts_param2(0, (0, import_common4.Inject)(import_nestjs_agent_core4.AGENT_OPTIONS)),
+  _ts_param2(1, (0, import_common4.Inject)(import_nestjs_agent_core3.AGENT_MODEL)),
+  _ts_param2(2, (0, import_common4.Inject)(import_nestjs_agent_core3.AGENT_STORE)),
+  _ts_param2(3, (0, import_common4.Inject)(import_nestjs_agent_core3.AGENT_SINK)),
+  _ts_param2(4, (0, import_common4.Inject)(import_nestjs_agent_core3.AGENT_ROLES_POLICY)),
+  _ts_param2(5, (0, import_common4.Inject)(import_nestjs_agent_core3.AGENT_TOOL_REGISTRY)),
+  _ts_param2(6, (0, import_common4.Inject)(import_nestjs_agent_core3.AGENT_REGISTRY)),
+  _ts_param2(7, (0, import_common4.Inject)(import_nestjs_agent_core3.AGENT_QUOTA_STORE)),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof AgentModuleOptions === "undefined" ? Object : AgentModuleOptions,
+    typeof ModelProvider === "undefined" ? Object : ModelProvider,
+    typeof AgentStore === "undefined" ? Object : AgentStore,
+    typeof TokenStreamSink === "undefined" ? Object : TokenStreamSink,
+    typeof RolesPolicy === "undefined" ? Object : RolesPolicy,
+    typeof import_nestjs_agent_core3.ToolRegistry === "undefined" ? Object : import_nestjs_agent_core3.ToolRegistry,
+    typeof import_nestjs_agent_core3.AgentRegistry === "undefined" ? Object : import_nestjs_agent_core3.AgentRegistry,
+    Object
+  ])
+], AgentDepsFactory2);
+
+// src/agent.service.ts
+var import_nestjs_agent_core5 = require("@dudousxd/nestjs-agent-core");
+var import_common5 = require("@nestjs/common");
+function _ts_decorate5(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") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate5, "_ts_decorate");
+function _ts_metadata4(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata4, "_ts_metadata");
+function _ts_param3(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param3, "_ts_param");
+var AgentService = class {
+  static {
+    __name(this, "AgentService");
+  }
+  runner;
+  store;
+  deps;
+  constructor(runner, store, deps) {
+    this.runner = runner;
+    this.store = store;
+    this.deps = deps;
+  }
+  async chat(params) {
+    const agentName = params.agentName ?? this.deps.defaultAgentName();
+    let threadId = params.threadId;
+    if (threadId === void 0) {
+      if (params.regenerate === true) {
+        throw new import_common5.BadRequestException("regenerate requires an existing threadId");
+      }
+      const created = await this.store.createThread({
+        actor: params.actor,
+        persona: params.personaId ?? this.deps.forAgent(agentName).defaultPersona
+      });
+      threadId = created.id;
+    } else if (params.regenerate === true) {
+      await this.assertOwnsThread(params.actor, threadId);
+    }
+    const persona = this.resolvePersona(agentName, params.personaId);
+    const input = {
+      threadId,
+      actor: params.actor,
+      userText: params.message,
+      day: utcDay(),
+      agentName,
+      ...params.regenerate === true ? {
+        regenerate: true
+      } : {},
+      ...persona !== void 0 ? {
+        persona
+      } : {},
+      ...params.pageContext !== void 0 ? {
+        pageContext: params.pageContext
+      } : {}
+    };
+    const { runId } = await this.runner.start(input);
+    await this.store.setActiveStream(threadId, runId);
+    return {
+      runId,
+      threadId
+    };
+  }
+  subscribe(runId) {
+    return this.deps.forAgent().sink.subscribe(runId);
+  }
+  async approve(actor, toolCallId) {
+    const runId = await this.runForOwnedToolCall(actor, toolCallId);
+    return this.runner.signal(runId, toolCallId, {
+      approved: true
+    });
+  }
+  async reject(actor, toolCallId, reason) {
+    const runId = await this.runForOwnedToolCall(actor, toolCallId);
+    return this.runner.signal(runId, toolCallId, {
+      approved: false,
+      ...reason !== void 0 ? {
+        reason
+      } : {}
+    });
+  }
+  async cancel(actor, runId) {
+    await this.assertOwnsActiveStream(actor, runId);
+    return this.runner.cancel(runId);
+  }
+  resolvePersona(agentName, id) {
+    const deps = this.deps.forAgent(agentName);
+    return deps.personas.get(id ?? deps.defaultPersona);
+  }
+  personaCatalog(agentName) {
+    return [
+      ...this.deps.forAgent(agentName).personas.values()
+    ].map((persona) => ({
+      id: persona.id,
+      label: persona.label
+    }));
+  }
+  listThreads(actorRef) {
+    return this.store.listThreads(actorRef);
+  }
+  async getThread(actor, threadId) {
+    await this.assertOwnsThread(actor, threadId);
+    return this.store.getThread(threadId);
+  }
+  async deleteThread(actor, threadId) {
+    await this.assertOwnsThread(actor, threadId);
+    return this.store.softDeleteThread(threadId);
+  }
+  async forkThread(actor, threadId, fromMessageId) {
+    await this.assertOwnsThread(actor, threadId);
+    return this.store.forkThread(threadId, fromMessageId);
+  }
+  async quotaToday(actorRef) {
+    return this.store.quotaToday(actorRef, utcDay());
+  }
+  /**
+  * Authorization seam for thread-scoped endpoints: the caller must own the thread. A missing
+  * thread is a 404; someone else's thread is a 403 — one actor never touches another's thread.
+  */
+  async assertOwnsThread(actor, threadId) {
+    const owner = await this.store.ownerOfThread(threadId);
+    if (owner === null) {
+      throw new import_common5.NotFoundException(`thread ${threadId} not found`);
+    }
+    if (owner !== actor.id) {
+      throw new import_common5.ForbiddenException("thread belongs to another actor");
+    }
+  }
+  /**
+  * Authorization + routing seam for HITL approve/reject: assert the caller owns the tool call's
+  * thread, then resolve the run currently awaiting that call (its thread's active stream). That run
+  * is the sub-agent's own child run when the pending call belongs to a delegated agent — the client
+  * never knows or supplies a runId; it is derived here from the tool call alone.
+  */
+  async runForOwnedToolCall(actor, toolCallId) {
+    const owner = await this.store.ownerOfToolCall(toolCallId);
+    if (owner === null) {
+      throw new import_common5.NotFoundException(`tool call ${toolCallId} not found`);
+    }
+    if (owner !== actor.id) {
+      throw new import_common5.ForbiddenException("tool call belongs to another actor");
+    }
+    const runId = await this.store.runForToolCall(toolCallId);
+    if (runId === null) {
+      throw new import_common5.NotFoundException(`tool call ${toolCallId} has no active run to signal`);
+    }
+    return runId;
+  }
+  /** Authorization seam for `cancel`: the caller must own the thread currently streaming this run. */
+  async assertOwnsActiveStream(actor, runId) {
+    const owner = await this.store.ownerOfActiveStream(runId);
+    if (owner === null) {
+      throw new import_common5.NotFoundException(`no active run ${runId}`);
+    }
+    if (owner !== actor.id) {
+      throw new import_common5.ForbiddenException("run belongs to another actor");
+    }
+  }
+};
+AgentService = _ts_decorate5([
+  (0, import_common5.Injectable)(),
+  _ts_param3(0, (0, import_common5.Inject)(import_nestjs_agent_core5.AGENT_RUNNER)),
+  _ts_param3(1, (0, import_common5.Inject)(import_nestjs_agent_core5.AGENT_STORE)),
+  _ts_param3(2, (0, import_common5.Inject)(import_nestjs_agent_core5.AGENT_DEPS_FACTORY)),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
+    typeof AgentRunner === "undefined" ? Object : AgentRunner,
+    typeof AgentStore === "undefined" ? Object : AgentStore,
+    typeof AgentDepsFactory === "undefined" ? Object : AgentDepsFactory
+  ])
+], AgentService);
+
+// src/controller/chat.controller.ts
+var import_nestjs_agent_core6 = require("@dudousxd/nestjs-agent-core");
+var import_common6 = require("@nestjs/common");
+function _ts_decorate6(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") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate6, "_ts_decorate");
+function _ts_metadata5(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata5, "_ts_metadata");
+function _ts_param4(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param4, "_ts_param");
+var ChatController = class {
+  static {
+    __name(this, "ChatController");
+  }
+  agent;
+  actorResolver;
+  constructor(agent, actorResolver) {
+    this.agent = agent;
+    this.actorResolver = actorResolver;
+  }
+  async chat(req, res, body) {
+    const actor = await this.actorResolver.resolve(req);
+    const { runId, threadId } = await this.agent.chat({
+      actor,
+      message: body.message,
+      ...body.threadId !== void 0 ? {
+        threadId: body.threadId
+      } : {},
+      ...body.agent !== void 0 ? {
+        agentName: body.agent
+      } : {},
+      ...body.persona !== void 0 ? {
+        personaId: body.persona
+      } : {},
+      ...body.pageContext !== void 0 ? {
+        pageContext: body.pageContext
+      } : {},
+      ...body.regenerate === true ? {
+        regenerate: true
+      } : {}
+    });
+    await this.pipe(res, runId, threadId);
+  }
+  async stream(runId, res) {
+    await this.pipe(res, runId);
+  }
+  async cancel(req, runId) {
+    const actor = await this.actorResolver.resolve(req);
+    await this.agent.cancel(actor, runId);
+    return {
+      aborted: true
+    };
+  }
+  async pipe(res, runId, threadId) {
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    res.setHeader("X-Agent-Run-Id", runId);
+    if (threadId !== void 0) {
+      res.setHeader("X-Agent-Thread-Id", threadId);
+    }
+    res.write(`event: meta
+data: ${JSON.stringify({
+      runId,
+      threadId
+    })}
+
+`);
+    const decoder = new TextDecoder();
+    try {
+      for await (const chunk of this.agent.subscribe(runId)) {
+        res.write(`data: ${JSON.stringify({
+          delta: decoder.decode(chunk)
+        })}
+
+`);
+      }
+      res.write("event: done\ndata: {}\n\n");
+    } catch (error) {
+      const payload = error instanceof import_nestjs_agent_core6.AgentStreamError ? {
+        code: error.code,
+        message: error.message
+      } : {
+        code: "run_failed",
+        message: error instanceof Error ? error.message : "stream error"
+      };
+      res.write(`event: error
+data: ${JSON.stringify(payload)}
+
+`);
+    }
+    res.end();
+  }
+};
+_ts_decorate6([
+  (0, import_common6.Post)("chat"),
+  _ts_param4(0, (0, import_common6.Req)()),
+  _ts_param4(1, (0, import_common6.Res)()),
+  _ts_param4(2, (0, import_common6.Body)()),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
+    typeof Request === "undefined" ? Object : Request,
+    typeof Response === "undefined" ? Object : Response,
+    typeof ChatBody === "undefined" ? Object : ChatBody
+  ]),
+  _ts_metadata5("design:returntype", Promise)
+], ChatController.prototype, "chat", null);
+_ts_decorate6([
+  (0, import_common6.Get)("chat/:runId/stream"),
+  _ts_param4(0, (0, import_common6.Param)("runId")),
+  _ts_param4(1, (0, import_common6.Res)()),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
+    String,
+    typeof Response === "undefined" ? Object : Response
+  ]),
+  _ts_metadata5("design:returntype", Promise)
+], ChatController.prototype, "stream", null);
+_ts_decorate6([
+  (0, import_common6.Post)("chat/:runId/cancel"),
+  _ts_param4(0, (0, import_common6.Req)()),
+  _ts_param4(1, (0, import_common6.Param)("runId")),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
+    typeof Request === "undefined" ? Object : Request,
+    String
+  ]),
+  _ts_metadata5("design:returntype", Promise)
+], ChatController.prototype, "cancel", null);
+ChatController = _ts_decorate6([
+  (0, import_common6.Controller)(),
+  _ts_param4(1, (0, import_common6.Inject)(import_nestjs_agent_core6.AGENT_ACTOR_RESOLVER)),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
+    typeof AgentService === "undefined" ? Object : AgentService,
+    typeof ActorResolver === "undefined" ? Object : ActorResolver
+  ])
+], ChatController);
+
+// src/controller/quota.controller.ts
+var import_nestjs_agent_core7 = require("@dudousxd/nestjs-agent-core");
+var import_common7 = require("@nestjs/common");
+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") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate7, "_ts_decorate");
+function _ts_metadata6(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata6, "_ts_metadata");
+function _ts_param5(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param5, "_ts_param");
+var QuotaController = class {
+  static {
+    __name(this, "QuotaController");
+  }
+  agent;
+  actorResolver;
+  constructor(agent, actorResolver) {
+    this.agent = agent;
+    this.actorResolver = actorResolver;
+  }
+  async today(req) {
+    const actor = await this.actorResolver.resolve(req);
+    return this.agent.quotaToday(actor.id);
+  }
+};
+_ts_decorate7([
+  (0, import_common7.Get)("today"),
+  _ts_param5(0, (0, import_common7.Req)()),
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("design:paramtypes", [
+    typeof Request === "undefined" ? Object : Request
+  ]),
+  _ts_metadata6("design:returntype", Promise)
+], QuotaController.prototype, "today", null);
+QuotaController = _ts_decorate7([
+  (0, import_common7.Controller)("quota"),
+  _ts_param5(1, (0, import_common7.Inject)(import_nestjs_agent_core7.AGENT_ACTOR_RESOLVER)),
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("design:paramtypes", [
+    typeof AgentService === "undefined" ? Object : AgentService,
+    typeof ActorResolver === "undefined" ? Object : ActorResolver
+  ])
+], QuotaController);
+
+// src/controller/threads.controller.ts
+var import_nestjs_agent_core8 = require("@dudousxd/nestjs-agent-core");
+var import_common8 = require("@nestjs/common");
+function _ts_decorate8(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") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate8, "_ts_decorate");
+function _ts_metadata7(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata7, "_ts_metadata");
+function _ts_param6(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param6, "_ts_param");
+var ThreadsController = class {
+  static {
+    __name(this, "ThreadsController");
+  }
+  agent;
+  actorResolver;
+  constructor(agent, actorResolver) {
+    this.agent = agent;
+    this.actorResolver = actorResolver;
+  }
+  async list(req) {
+    const actor = await this.actorResolver.resolve(req);
+    return this.agent.listThreads(actor.id);
+  }
+  personas() {
+    return this.agent.personaCatalog();
+  }
+  async detail(req, id) {
+    const actor = await this.actorResolver.resolve(req);
+    return this.agent.getThread(actor, id);
+  }
+  async remove(req, id) {
+    const actor = await this.actorResolver.resolve(req);
+    await this.agent.deleteThread(actor, id);
+    return {
+      ok: true
+    };
+  }
+  async fork(req, id, messageId) {
+    const actor = await this.actorResolver.resolve(req);
+    return this.agent.forkThread(actor, id, messageId);
+  }
+};
+_ts_decorate8([
+  (0, import_common8.Get)(),
+  _ts_param6(0, (0, import_common8.Req)()),
+  _ts_metadata7("design:type", Function),
+  _ts_metadata7("design:paramtypes", [
+    typeof Request === "undefined" ? Object : Request
+  ]),
+  _ts_metadata7("design:returntype", Promise)
+], ThreadsController.prototype, "list", null);
+_ts_decorate8([
+  (0, import_common8.Get)("personas/catalog"),
+  _ts_metadata7("design:type", Function),
+  _ts_metadata7("design:paramtypes", []),
+  _ts_metadata7("design:returntype", void 0)
+], ThreadsController.prototype, "personas", null);
+_ts_decorate8([
+  (0, import_common8.Get)(":id"),
+  _ts_param6(0, (0, import_common8.Req)()),
+  _ts_param6(1, (0, import_common8.Param)("id")),
+  _ts_metadata7("design:type", Function),
+  _ts_metadata7("design:paramtypes", [
+    typeof Request === "undefined" ? Object : Request,
+    String
+  ]),
+  _ts_metadata7("design:returntype", Promise)
+], ThreadsController.prototype, "detail", null);
+_ts_decorate8([
+  (0, import_common8.Delete)(":id"),
+  _ts_param6(0, (0, import_common8.Req)()),
+  _ts_param6(1, (0, import_common8.Param)("id")),
+  _ts_metadata7("design:type", Function),
+  _ts_metadata7("design:paramtypes", [
+    typeof Request === "undefined" ? Object : Request,
+    String
+  ]),
+  _ts_metadata7("design:returntype", Promise)
+], ThreadsController.prototype, "remove", null);
+_ts_decorate8([
+  (0, import_common8.Post)(":id/fork-from/:messageId"),
+  _ts_param6(0, (0, import_common8.Req)()),
+  _ts_param6(1, (0, import_common8.Param)("id")),
+  _ts_param6(2, (0, import_common8.Param)("messageId")),
+  _ts_metadata7("design:type", Function),
+  _ts_metadata7("design:paramtypes", [
+    typeof Request === "undefined" ? Object : Request,
+    String,
+    String
+  ]),
+  _ts_metadata7("design:returntype", Promise)
+], ThreadsController.prototype, "fork", null);
+ThreadsController = _ts_decorate8([
+  (0, import_common8.Controller)("threads"),
+  _ts_param6(1, (0, import_common8.Inject)(import_nestjs_agent_core8.AGENT_ACTOR_RESOLVER)),
+  _ts_metadata7("design:type", Function),
+  _ts_metadata7("design:paramtypes", [
+    typeof AgentService === "undefined" ? Object : AgentService,
+    typeof ActorResolver === "undefined" ? Object : ActorResolver
+  ])
+], ThreadsController);
+
+// src/controller/tool-call.controller.ts
+var import_nestjs_agent_core9 = require("@dudousxd/nestjs-agent-core");
+var import_common9 = require("@nestjs/common");
+function _ts_decorate9(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") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate9, "_ts_decorate");
+function _ts_metadata8(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata8, "_ts_metadata");
+function _ts_param7(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param7, "_ts_param");
+var ToolCallController = class {
+  static {
+    __name(this, "ToolCallController");
+  }
+  agent;
+  actorResolver;
+  constructor(agent, actorResolver) {
+    this.agent = agent;
+    this.actorResolver = actorResolver;
+  }
+  async approve(req, body) {
+    const actor = await this.actorResolver.resolve(req);
+    await this.agent.approve(actor, body.toolCallId);
+    return {
+      ok: true
+    };
+  }
+  async reject(req, body) {
+    const actor = await this.actorResolver.resolve(req);
+    await this.agent.reject(actor, body.toolCallId, body.reason);
+    return {
+      ok: true
+    };
+  }
+};
+_ts_decorate9([
+  (0, import_common9.Post)("approve"),
+  _ts_param7(0, (0, import_common9.Req)()),
+  _ts_param7(1, (0, import_common9.Body)()),
+  _ts_metadata8("design:type", Function),
+  _ts_metadata8("design:paramtypes", [
+    typeof Request === "undefined" ? Object : Request,
+    typeof ApproveBody === "undefined" ? Object : ApproveBody
+  ]),
+  _ts_metadata8("design:returntype", Promise)
+], ToolCallController.prototype, "approve", null);
+_ts_decorate9([
+  (0, import_common9.Post)("reject"),
+  _ts_param7(0, (0, import_common9.Req)()),
+  _ts_param7(1, (0, import_common9.Body)()),
+  _ts_metadata8("design:type", Function),
+  _ts_metadata8("design:paramtypes", [
+    typeof Request === "undefined" ? Object : Request,
+    typeof RejectBody === "undefined" ? Object : RejectBody
+  ]),
+  _ts_metadata8("design:returntype", Promise)
+], ToolCallController.prototype, "reject", null);
+ToolCallController = _ts_decorate9([
+  (0, import_common9.Controller)("tool-call"),
+  _ts_param7(1, (0, import_common9.Inject)(import_nestjs_agent_core9.AGENT_ACTOR_RESOLVER)),
+  _ts_metadata8("design:type", Function),
+  _ts_metadata8("design:paramtypes", [
+    typeof AgentService === "undefined" ? Object : AgentService,
+    typeof ActorResolver === "undefined" ? Object : ActorResolver
+  ])
+], ToolCallController);
+
+// src/discovery/ai-tool-discovery.service.ts
+var import_nestjs_agent_core10 = require("@dudousxd/nestjs-agent-core");
+var import_common10 = require("@nestjs/common");
+var import_core = require("@nestjs/core");
+var import_zod = require("zod");
+
+// src/decorator/ai-tool.decorator.ts
+var import_reflect_metadata = require("reflect-metadata");
+var AI_TOOL_METADATA = Symbol("nestjs-agent:ai-tool");
+function readAiToolMetadata(target) {
+  return Reflect.getMetadata(AI_TOOL_METADATA, target.constructor);
+}
+__name(readAiToolMetadata, "readAiToolMetadata");
+
+// src/functional-tool.ts
+var AGENT_TOOL_BRAND = Symbol.for("@dudousxd/nestjs-agent:functional-tool");
+function isBrandedFunctionalTool(value) {
+  return AGENT_TOOL_BRAND in value && "spec" in value && "handler" in value;
+}
+__name(isBrandedFunctionalTool, "isBrandedFunctionalTool");
+
+// src/discovery/ai-tool-discovery.service.ts
+function _ts_decorate10(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") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate10, "_ts_decorate");
+function _ts_metadata9(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata9, "_ts_metadata");
+function _ts_param8(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param8, "_ts_param");
+var AiToolDiscoveryService = class _AiToolDiscoveryService {
+  static {
+    __name(this, "AiToolDiscoveryService");
+  }
+  discovery;
+  registry;
+  agents;
+  options;
+  logger = new import_common10.Logger(_AiToolDiscoveryService.name);
+  constructor(discovery, registry, agents, options) {
+    this.discovery = discovery;
+    this.registry = registry;
+    this.agents = agents;
+    this.options = options;
+  }
+  onApplicationBootstrap() {
+    let count = 0;
+    let functional = 0;
+    for (const wrapper of this.discovery.getProviders()) {
+      const instance = wrapper.instance;
+      if (instance === null || instance === void 0 || typeof instance !== "object") {
+        continue;
+      }
+      if (isBrandedFunctionalTool(instance)) {
+        if (this.registerFunctionalTool(instance)) {
+          functional += 1;
+        }
+        continue;
+      }
+      const meta = readAiToolMetadata(instance);
+      if (meta === void 0) {
+        continue;
+      }
+      const handler = instance;
+      if (typeof handler.execute !== "function") {
+        this.logger.warn(`@AiTool "${meta.name}" has no execute() method \u2014 skipped`);
+        continue;
+      }
+      this.registry.register({
+        name: meta.name,
+        kind: meta.kind,
+        description: meta.description,
+        inputSchema: meta.input,
+        // Leave roles unset when the tool didn't declare any — the RolesPolicy owns the default
+        // (its `defaultRoles`). Baking it in here too would leak it into custom policies.
+        ...meta.roles !== void 0 ? {
+          roles: meta.roles
+        } : {},
+        ...meta.ability !== void 0 ? {
+          ability: meta.ability
+        } : {}
+      }, {
+        execute: /* @__PURE__ */ __name((input, ctx) => instance.execute(input, ctx), "execute")
+      });
+      count += 1;
+    }
+    for (const tool of this.options.tools ?? []) {
+      if (this.registerFunctionalTool(tool)) {
+        functional += 1;
+      }
+    }
+    let delegates = 0;
+    for (const definition of this.agents.list()) {
+      for (const target of definition.delegatesTo ?? []) {
+        const targetDefinition = this.agents.get(target);
+        if (targetDefinition === void 0) {
+          throw new Error(`Agent "${definition.name}" delegatesTo "${target}", which is not a registered agent. Register it via AgentModule.forFeature([...]) or fix the name.`);
+        }
+        const name = delegateToolName(target);
+        if (this.registry.has(name)) {
+          continue;
+        }
+        const targetBlurb = typeof targetDefinition.systemPrompt === "string" ? ` It is: ${targetDefinition.systemPrompt}` : "";
+        this.registry.register(
+          {
+            name,
+            kind: "agent",
+            targetAgent: target,
+            description: `Delegate a task to the "${target}" agent and get its answer.${targetBlurb}`,
+            inputSchema: import_zod.z.object({
+              task: import_zod.z.string()
+            })
+          },
+          // Loop-handled (kind 'agent'); the handler is never called.
+          {
+            execute: /* @__PURE__ */ __name(async () => ({}), "execute")
+          }
+        );
+        delegates += 1;
+      }
+    }
+    this.logger.log(`registered ${count} AI tool(s), ${functional} functional tool(s) and ${delegates} delegate tool(s)`);
+  }
+  /**
+  * Registers a functional tool's `{ spec, handler }`, skipping it if a tool of the same name is
+  * already registered. Returns whether it was newly registered.
+  */
+  registerFunctionalTool(tool) {
+    if (this.registry.has(tool.spec.name)) {
+      this.logger.warn(`functional tool "${tool.spec.name}" duplicates a registered name \u2014 skipped`);
+      return false;
+    }
+    this.registry.register(tool.spec, tool.handler);
+    return true;
+  }
+};
+AiToolDiscoveryService = _ts_decorate10([
+  (0, import_common10.Injectable)(),
+  _ts_param8(1, (0, import_common10.Inject)(import_nestjs_agent_core10.AGENT_TOOL_REGISTRY)),
+  _ts_param8(2, (0, import_common10.Inject)(import_nestjs_agent_core10.AGENT_REGISTRY)),
+  _ts_param8(3, (0, import_common10.Inject)(import_nestjs_agent_core10.AGENT_OPTIONS)),
+  _ts_metadata9("design:type", Function),
+  _ts_metadata9("design:paramtypes", [
+    typeof import_core.DiscoveryService === "undefined" ? Object : import_core.DiscoveryService,
+    typeof ToolRegistry === "undefined" ? Object : ToolRegistry,
+    typeof AgentRegistry === "undefined" ? Object : AgentRegistry,
+    typeof AgentModuleOptions === "undefined" ? Object : AgentModuleOptions
+  ])
+], AiToolDiscoveryService);
+
+// src/in-process-sink.ts
+var import_nestjs_agent_core11 = require("@dudousxd/nestjs-agent-core");
+var InProcessTokenStreamSink = class {
+  static {
+    __name(this, "InProcessTokenStreamSink");
+  }
+  runs = /* @__PURE__ */ new Map();
+  buffer(runId) {
+    let buf = this.runs.get(runId);
+    if (buf === void 0) {
+      buf = {
+        chunks: [],
+        ended: false,
+        notify: /* @__PURE__ */ new Set()
+      };
+      this.runs.set(runId, buf);
+    }
+    return buf;
+  }
+  wake(buf) {
+    for (const resolve of buf.notify) {
+      resolve();
+    }
+    buf.notify.clear();
+  }
+  open(runId) {
+    const buf = this.buffer(runId);
+    return {
+      write: /* @__PURE__ */ __name((chunk) => {
+        buf.chunks.push(chunk);
+        this.wake(buf);
+      }, "write"),
+      end: /* @__PURE__ */ __name(() => {
+        buf.ended = true;
+        this.wake(buf);
+      }, "end"),
+      fail: /* @__PURE__ */ __name((error) => {
+        buf.failure = error;
+        buf.ended = true;
+        this.wake(buf);
+      }, "fail")
+    };
+  }
+  async *subscribe(runId) {
+    const buf = this.buffer(runId);
+    let index = 0;
+    while (true) {
+      while (index < buf.chunks.length) {
+        const chunk = buf.chunks[index];
+        index += 1;
+        if (chunk !== void 0) {
+          yield chunk;
+        }
+      }
+      if (buf.ended) {
+        if (buf.failure !== void 0) {
+          throw new import_nestjs_agent_core11.AgentStreamError(buf.failure);
+        }
+        return;
+      }
+      await new Promise((resolve) => buf.notify.add(resolve));
+    }
+  }
+  close(runId) {
+    this.runs.delete(runId);
+  }
+};
+
+// src/ledger-quota-store.ts
+var LedgerQuotaStore = class {
+  static {
+    __name(this, "LedgerQuotaStore");
+  }
+  store;
+  limitTokens;
+  constructor(store, limitTokens) {
+    this.store = store;
+    this.limitTokens = limitTokens;
+  }
+  async check(actorRef, day) {
+    const { usedTokens } = await this.store.quotaToday(actorRef, day);
+    return {
+      usedTokens,
+      limitTokens: this.limitTokens,
+      withinLimit: usedTokens < this.limitTokens
+    };
+  }
+  async bump() {
+  }
+};
+
+// src/runner/inline-agent-runner.ts
+var import_nestjs_agent_core12 = require("@dudousxd/nestjs-agent-core");
+var import_common11 = require("@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;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate11, "_ts_decorate");
+function _ts_metadata10(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata10, "_ts_metadata");
+function _ts_param9(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param9, "_ts_param");
+var InlineAgentRunner = class _InlineAgentRunner {
+  static {
+    __name(this, "InlineAgentRunner");
+  }
+  factory;
+  store;
+  logger = new import_common11.Logger(_InlineAgentRunner.name);
+  pending = /* @__PURE__ */ new Map();
+  constructor(factory, store) {
+    this.factory = factory;
+    this.store = store;
+  }
+  async start(input) {
+    const runId = crypto.randomUUID();
+    const day = input.day ?? utcDay();
+    const deps = this.factory.forAgent(input.agentName);
+    const hooks = this.topLevelHooks(runId, deps, input.actor, day);
+    void (0, import_nestjs_agent_core12.runAgentLoop)({
+      ...deps,
+      day
+    }, input, hooks).catch(async (error) => {
+      const message = error instanceof Error ? error.message : String(error);
+      const code = error instanceof import_nestjs_agent_core12.QuotaExceededError ? "quota_exceeded" : "run_failed";
+      this.logger.error(`agent run ${runId} failed (${code}): ${message}`);
+      (0, import_nestjs_agent_core12.publishAgentRunFailed)({
+        runId,
+        code,
+        message
+      });
+      const writer = await deps.sink.open(runId);
+      await writer.fail({
+        code,
+        message
+      });
+    });
+    return {
+      runId
+    };
+  }
+  async signal(runId, toolCallId, decision) {
+    const key = `${runId}:${toolCallId}`;
+    const resolve = this.pending.get(key);
+    if (resolve !== void 0) {
+      this.pending.delete(key);
+      resolve(decision);
+    }
+  }
+  async cancel(runId) {
+    const deps = this.factory.forAgent();
+    const writer = await deps.sink.open(runId);
+    await writer.end();
+  }
+  topLevelHooks(runId, deps, actor, day) {
+    return {
+      runId,
+      openSink: /* @__PURE__ */ __name(() => deps.sink.open(runId), "openSink"),
+      awaitApproval: /* @__PURE__ */ __name((call) => new Promise((resolve) => {
+        this.pending.set(`${runId}:${call.id}`, resolve);
+      }), "awaitApproval"),
+      step: /* @__PURE__ */ __name((_name, fn) => fn(), "step"),
+      runAgent: /* @__PURE__ */ __name((agentName, task) => this.runNested(agentName, task, actor, day, 1, runId), "runAgent")
+    };
+  }
+  /**
+  * Delegate to another agent as a nested in-process run. The sub-agent streams into `sinkRunId`
+  * (the top-level run the human is watching) so its output and any pending action tool are visible,
+  * and its own approvals resolve through the shared pending map keyed by its own runId.
+  */
+  async runNested(agentName, task, actor, day, depth, sinkRunId) {
+    const subThread = await this.store.createThread({
+      actor,
+      persona: "default",
+      transient: true
+    });
+    const runId = crypto.randomUUID();
+    await this.store.setActiveStream(subThread.id, runId);
+    const deps = this.factory.forAgent(agentName);
+    const hooks = {
+      runId,
+      // Forward into the top-level stream; the top-level run owns end/fail on that shared sink.
+      openSink: /* @__PURE__ */ __name(async () => childSinkWriter(await deps.sink.open(sinkRunId)), "openSink"),
+      awaitApproval: /* @__PURE__ */ __name((call) => new Promise((resolve) => {
+        this.pending.set(`${runId}:${call.id}`, resolve);
+      }), "awaitApproval"),
+      step: /* @__PURE__ */ __name((_name, fn) => fn(), "step"),
+      runAgent: /* @__PURE__ */ __name((childName, childTask) => this.runNested(childName, childTask, actor, day, depth + 1, sinkRunId), "runAgent")
+    };
+    return (0, import_nestjs_agent_core12.runAgentLoop)({
+      ...deps,
+      day
+    }, {
+      threadId: subThread.id,
+      actor,
+      userText: task,
+      agentName,
+      day,
+      delegationDepth: depth,
+      sinkRunId
+    }, hooks);
+  }
+};
+InlineAgentRunner = _ts_decorate11([
+  (0, import_common11.Injectable)(),
+  _ts_param9(0, (0, import_common11.Inject)(import_nestjs_agent_core12.AGENT_DEPS_FACTORY)),
+  _ts_param9(1, (0, import_common11.Inject)(import_nestjs_agent_core12.AGENT_STORE)),
+  _ts_metadata10("design:type", Function),
+  _ts_metadata10("design:paramtypes", [
+    typeof AgentDepsFactory === "undefined" ? Object : AgentDepsFactory,
+    typeof AgentStore === "undefined" ? Object : AgentStore
+  ])
+], InlineAgentRunner);
+
+// src/agent.module.ts
+function _ts_decorate12(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") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate12, "_ts_decorate");
+var FEATURE_INIT = Symbol("nestjs-agent:feature-init");
+var DEFAULT_PATH = "agent";
+function defaultDefinition(options) {
+  return {
+    name: "default",
+    ...options.defaultAgent
+  };
+}
+__name(defaultDefinition, "defaultDefinition");
+function sharedProviders(durable, includeStore) {
+  const providers = [
+    {
+      provide: import_nestjs_agent_core13.AGENT_TOOL_REGISTRY,
+      useFactory: /* @__PURE__ */ __name(() => new import_nestjs_agent_core13.ToolRegistry(), "useFactory")
+    },
+    {
+      provide: import_nestjs_agent_core13.AGENT_REGISTRY,
+      useFactory: /* @__PURE__ */ __name((options) => {
+        const registry = new import_nestjs_agent_core13.AgentRegistry();
+        registry.register(defaultDefinition(options));
+        return registry;
+      }, "useFactory"),
+      inject: [
+        import_nestjs_agent_core13.AGENT_OPTIONS
+      ]
+    },
+    {
+      provide: import_nestjs_agent_core13.AGENT_SINK,
+      useFactory: /* @__PURE__ */ __name((options) => options.sink ?? new InProcessTokenStreamSink(), "useFactory"),
+      inject: [
+        import_nestjs_agent_core13.AGENT_OPTIONS
+      ]
+    },
+    {
+      provide: import_nestjs_agent_core13.AGENT_ROLES_POLICY,
+      useFactory: /* @__PURE__ */ __name((options) => options.rolesPolicy ?? new import_nestjs_agent_core13.DefaultRolesPolicy(options.defaultRoles), "useFactory"),
+      inject: [
+        import_nestjs_agent_core13.AGENT_OPTIONS
+      ]
+    },
+    {
+      provide: import_nestjs_agent_core13.AGENT_ACTOR_RESOLVER,
+      useFactory: /* @__PURE__ */ __name((options) => options.actorResolver, "useFactory"),
+      inject: [
+        import_nestjs_agent_core13.AGENT_OPTIONS
+      ]
+    },
+    {
+      provide: import_nestjs_agent_core13.AGENT_MODEL,
+      useFactory: /* @__PURE__ */ __name((o) => o.model, "useFactory"),
+      inject: [
+        import_nestjs_agent_core13.AGENT_OPTIONS
+      ]
+    },
+    {
+      // An explicit `quota` wins; otherwise `quotaLimitTokens` binds the built-in ledger-backed
+      // store; otherwise quotas are off (undefined). The ledger store reads the same usage rows
+      // the loop already writes, so enforcement needs no extra shared state across replicas.
+      provide: import_nestjs_agent_core13.AGENT_QUOTA_STORE,
+      useFactory: /* @__PURE__ */ __name((o, store) => o.quota ?? (o.quotaLimitTokens !== void 0 ? new LedgerQuotaStore(store, o.quotaLimitTokens) : void 0), "useFactory"),
+      inject: [
+        import_nestjs_agent_core13.AGENT_OPTIONS,
+        import_nestjs_agent_core13.AGENT_STORE
+      ]
+    },
+    AgentDepsFactory2,
+    {
+      provide: import_nestjs_agent_core13.AGENT_DEPS_FACTORY,
+      useExisting: AgentDepsFactory2
+    },
+    AiToolDiscoveryService,
+    InlineAgentRunner,
+    AgentService
+  ];
+  if (includeStore) {
+    providers.push({
+      provide: import_nestjs_agent_core13.AGENT_STORE,
+      useFactory: /* @__PURE__ */ __name((o) => o.store, "useFactory"),
+      inject: [
+        import_nestjs_agent_core13.AGENT_OPTIONS
+      ]
+    });
+  }
+  if (durable) {
+    providers.push({
+      provide: import_nestjs_agent_core13.AGENT_RUNNER,
+      useFactory: /* @__PURE__ */ __name((durableRunner) => {
+        if (durableRunner === void 0) {
+          throw new Error("AgentModule.forRoot({ durable: true }) requires importing AgentDurableModule from '@dudousxd/nestjs-agent/durable' (alongside a configured DurableModule). It was not found.");
+        }
+        return durableRunner;
+      }, "useFactory"),
+      inject: [
+        {
+          token: import_nestjs_agent_core13.AGENT_DURABLE_RUNNER,
+          optional: true
+        }
+      ]
+    });
+  } else {
+    providers.push({
+      provide: import_nestjs_agent_core13.AGENT_RUNNER,
+      useExisting: InlineAgentRunner
+    });
+  }
+  return providers;
+}
+__name(sharedProviders, "sharedProviders");
+function exportsFor(includeStore) {
+  return [
+    import_nestjs_agent_core13.AGENT_OPTIONS,
+    import_nestjs_agent_core13.AGENT_TOOL_REGISTRY,
+    import_nestjs_agent_core13.AGENT_REGISTRY,
+    import_nestjs_agent_core13.AGENT_SINK,
+    import_nestjs_agent_core13.AGENT_ROLES_POLICY,
+    import_nestjs_agent_core13.AGENT_ACTOR_RESOLVER,
+    import_nestjs_agent_core13.AGENT_MODEL,
+    ...includeStore ? [
+      import_nestjs_agent_core13.AGENT_STORE
+    ] : [],
+    import_nestjs_agent_core13.AGENT_QUOTA_STORE,
+    import_nestjs_agent_core13.AGENT_DEPS_FACTORY,
+    AgentDepsFactory2,
+    AgentService,
+    InlineAgentRunner
+  ];
+}
+__name(exportsFor, "exportsFor");
+var CONTROLLERS = [
+  ChatController,
+  ThreadsController,
+  ToolCallController,
+  QuotaController
+];
+function routerFor(path) {
+  return import_core2.RouterModule.register([
+    {
+      path,
+      module: AgentModule
+    }
+  ]);
+}
+__name(routerFor, "routerFor");
+var AgentModule = class _AgentModule {
+  static {
+    __name(this, "AgentModule");
+  }
+  static forRoot(options) {
+    const path = options.path ?? DEFAULT_PATH;
+    const includeStore = options.store !== void 0;
+    return {
+      module: _AgentModule,
+      global: true,
+      imports: [
+        import_core2.DiscoveryModule,
+        routerFor(path)
+      ],
+      controllers: CONTROLLERS,
+      providers: [
+        {
+          provide: import_nestjs_agent_core13.AGENT_OPTIONS,
+          useValue: options
+        },
+        ...sharedProviders(options.durable ?? false, includeStore)
+      ],
+      exports: exportsFor(includeStore)
+    };
+  }
+  static forRootAsync(options) {
+    const path = options.path ?? DEFAULT_PATH;
+    return {
+      module: _AgentModule,
+      global: true,
+      imports: [
+        import_core2.DiscoveryModule,
+        routerFor(path),
+        ...options.imports ?? []
+      ],
+      controllers: CONTROLLERS,
+      providers: [
+        {
+          provide: import_nestjs_agent_core13.AGENT_OPTIONS,
+          useFactory: options.useFactory,
+          inject: options.inject ?? []
+        },
+        // The async factory resolves too late to inspect `store`, so we always bind AGENT_STORE here
+        // (its factory reads the resolved options). Omit-and-import-a-store-module is a `forRoot` path.
+        ...sharedProviders(options.durable ?? false, true)
+      ],
+      exports: exportsFor(true)
+    };
+  }
+  /** Register additional named agents (an orchestrator + its sub-agents). */
+  static forFeature(definitions) {
+    return {
+      module: _AgentModule,
+      providers: [
+        {
+          provide: FEATURE_INIT,
+          useFactory: /* @__PURE__ */ __name((registry) => {
+            for (const definition of definitions) {
+              registry.register(definition);
+            }
+            return true;
+          }, "useFactory"),
+          inject: [
+            import_nestjs_agent_core13.AGENT_REGISTRY
+          ]
+        }
+      ]
+    };
+  }
+};
+AgentModule = _ts_decorate12([
+  (0, import_common12.Global)(),
+  (0, import_common12.Module)({})
+], AgentModule);
+
+// src/durable/agent-durable.ts
+function agentDurable(options) {
+  return [
+    AgentModule.forRoot({
+      ...options,
+      durable: true
+    }),
+    AgentDurableModule.forRoot()
+  ];
+}
+__name(agentDurable, "agentDurable");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentDurableModule,
+  AgentRunWorkflow,
+  DurableAgentRunner,
+  agentDurable
+});
+//# sourceMappingURL=index.cjs.map