@dudousxd/nestjs-agent 0.1.0

package/dist/index.js

@@ -0,0 +1,1427 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/agent.module.ts
+import { AGENT_ACTOR_RESOLVER as AGENT_ACTOR_RESOLVER5, AGENT_DEPS_FACTORY as AGENT_DEPS_FACTORY3, AGENT_DURABLE_RUNNER, AGENT_MODEL as AGENT_MODEL2, AGENT_OPTIONS as AGENT_OPTIONS3, AGENT_QUOTA_STORE as AGENT_QUOTA_STORE2, AGENT_REGISTRY as AGENT_REGISTRY3, AGENT_ROLES_POLICY as AGENT_ROLES_POLICY2, AGENT_RUNNER as AGENT_RUNNER2, AGENT_SINK as AGENT_SINK2, AGENT_STORE as AGENT_STORE4, AGENT_TOOL_REGISTRY as AGENT_TOOL_REGISTRY3, AgentRegistry as AgentRegistry3, DefaultRolesPolicy, ToolRegistry as ToolRegistry3 } from "@dudousxd/nestjs-agent-core";
+import { Global, Module } from "@nestjs/common";
+import { DiscoveryModule, RouterModule } from "@nestjs/core";
+
+// src/agent-deps.factory.ts
+import { AGENT_MODEL, AGENT_QUOTA_STORE, AGENT_REGISTRY, AGENT_ROLES_POLICY, AGENT_SINK, AGENT_STORE, AGENT_TOOL_REGISTRY, AgentRegistry as AgentRegistry2, ToolRegistry as ToolRegistry2 } from "@dudousxd/nestjs-agent-core";
+import { AGENT_OPTIONS } from "@dudousxd/nestjs-agent-core";
+import { Inject, Injectable } from "@nestjs/common";
+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");
+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_decorate([
+  Injectable(),
+  _ts_param(0, Inject(AGENT_OPTIONS)),
+  _ts_param(1, Inject(AGENT_MODEL)),
+  _ts_param(2, Inject(AGENT_STORE)),
+  _ts_param(3, Inject(AGENT_SINK)),
+  _ts_param(4, Inject(AGENT_ROLES_POLICY)),
+  _ts_param(5, Inject(AGENT_TOOL_REGISTRY)),
+  _ts_param(6, Inject(AGENT_REGISTRY)),
+  _ts_param(7, Inject(AGENT_QUOTA_STORE)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("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 ToolRegistry2 === "undefined" ? Object : ToolRegistry2,
+    typeof AgentRegistry2 === "undefined" ? Object : AgentRegistry2,
+    Object
+  ])
+], AgentDepsFactory2);
+
+// src/agent.service.ts
+import { AGENT_DEPS_FACTORY, AGENT_RUNNER, AGENT_STORE as AGENT_STORE2 } from "@dudousxd/nestjs-agent-core";
+import { BadRequestException, ForbiddenException, Inject as Inject2, Injectable as Injectable2, NotFoundException } from "@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/agent.service.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") 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");
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_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 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 NotFoundException(`thread ${threadId} not found`);
+    }
+    if (owner !== actor.id) {
+      throw new 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 NotFoundException(`tool call ${toolCallId} not found`);
+    }
+    if (owner !== actor.id) {
+      throw new ForbiddenException("tool call belongs to another actor");
+    }
+    const runId = await this.store.runForToolCall(toolCallId);
+    if (runId === null) {
+      throw new 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 NotFoundException(`no active run ${runId}`);
+    }
+    if (owner !== actor.id) {
+      throw new ForbiddenException("run belongs to another actor");
+    }
+  }
+};
+AgentService = _ts_decorate2([
+  Injectable2(),
+  _ts_param2(0, Inject2(AGENT_RUNNER)),
+  _ts_param2(1, Inject2(AGENT_STORE2)),
+  _ts_param2(2, Inject2(AGENT_DEPS_FACTORY)),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof AgentRunner === "undefined" ? Object : AgentRunner,
+    typeof AgentStore === "undefined" ? Object : AgentStore,
+    typeof AgentDepsFactory === "undefined" ? Object : AgentDepsFactory
+  ])
+], AgentService);
+
+// src/controller/chat.controller.ts
+import { AGENT_ACTOR_RESOLVER, AgentStreamError } from "@dudousxd/nestjs-agent-core";
+import { Body, Controller, Get, Inject as Inject3, Param, Post, Req, Res } from "@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");
+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_param3(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param3, "_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 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_decorate3([
+  Post("chat"),
+  _ts_param3(0, Req()),
+  _ts_param3(1, Res()),
+  _ts_param3(2, Body()),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof Request === "undefined" ? Object : Request,
+    typeof Response === "undefined" ? Object : Response,
+    typeof ChatBody === "undefined" ? Object : ChatBody
+  ]),
+  _ts_metadata3("design:returntype", Promise)
+], ChatController.prototype, "chat", null);
+_ts_decorate3([
+  Get("chat/:runId/stream"),
+  _ts_param3(0, Param("runId")),
+  _ts_param3(1, Res()),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    String,
+    typeof Response === "undefined" ? Object : Response
+  ]),
+  _ts_metadata3("design:returntype", Promise)
+], ChatController.prototype, "stream", null);
+_ts_decorate3([
+  Post("chat/:runId/cancel"),
+  _ts_param3(0, Req()),
+  _ts_param3(1, Param("runId")),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof Request === "undefined" ? Object : Request,
+    String
+  ]),
+  _ts_metadata3("design:returntype", Promise)
+], ChatController.prototype, "cancel", null);
+ChatController = _ts_decorate3([
+  Controller(),
+  _ts_param3(1, Inject3(AGENT_ACTOR_RESOLVER)),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof AgentService === "undefined" ? Object : AgentService,
+    typeof ActorResolver === "undefined" ? Object : ActorResolver
+  ])
+], ChatController);
+
+// src/controller/quota.controller.ts
+import { AGENT_ACTOR_RESOLVER as AGENT_ACTOR_RESOLVER2 } from "@dudousxd/nestjs-agent-core";
+import { Controller as Controller2, Get as Get2, Inject as Inject4, Req as Req2 } from "@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_metadata4(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata4, "_ts_metadata");
+function _ts_param4(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param4, "_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_decorate4([
+  Get2("today"),
+  _ts_param4(0, Req2()),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
+    typeof Request === "undefined" ? Object : Request
+  ]),
+  _ts_metadata4("design:returntype", Promise)
+], QuotaController.prototype, "today", null);
+QuotaController = _ts_decorate4([
+  Controller2("quota"),
+  _ts_param4(1, Inject4(AGENT_ACTOR_RESOLVER2)),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
+    typeof AgentService === "undefined" ? Object : AgentService,
+    typeof ActorResolver === "undefined" ? Object : ActorResolver
+  ])
+], QuotaController);
+
+// src/controller/threads.controller.ts
+import { AGENT_ACTOR_RESOLVER as AGENT_ACTOR_RESOLVER3 } from "@dudousxd/nestjs-agent-core";
+import { Controller as Controller3, Delete, Get as Get3, Inject as Inject5, Param as Param2, Post as Post2, Req as Req3 } from "@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_metadata5(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata5, "_ts_metadata");
+function _ts_param5(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param5, "_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_decorate5([
+  Get3(),
+  _ts_param5(0, Req3()),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
+    typeof Request === "undefined" ? Object : Request
+  ]),
+  _ts_metadata5("design:returntype", Promise)
+], ThreadsController.prototype, "list", null);
+_ts_decorate5([
+  Get3("personas/catalog"),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", []),
+  _ts_metadata5("design:returntype", void 0)
+], ThreadsController.prototype, "personas", null);
+_ts_decorate5([
+  Get3(":id"),
+  _ts_param5(0, Req3()),
+  _ts_param5(1, Param2("id")),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
+    typeof Request === "undefined" ? Object : Request,
+    String
+  ]),
+  _ts_metadata5("design:returntype", Promise)
+], ThreadsController.prototype, "detail", null);
+_ts_decorate5([
+  Delete(":id"),
+  _ts_param5(0, Req3()),
+  _ts_param5(1, Param2("id")),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
+    typeof Request === "undefined" ? Object : Request,
+    String
+  ]),
+  _ts_metadata5("design:returntype", Promise)
+], ThreadsController.prototype, "remove", null);
+_ts_decorate5([
+  Post2(":id/fork-from/:messageId"),
+  _ts_param5(0, Req3()),
+  _ts_param5(1, Param2("id")),
+  _ts_param5(2, Param2("messageId")),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
+    typeof Request === "undefined" ? Object : Request,
+    String,
+    String
+  ]),
+  _ts_metadata5("design:returntype", Promise)
+], ThreadsController.prototype, "fork", null);
+ThreadsController = _ts_decorate5([
+  Controller3("threads"),
+  _ts_param5(1, Inject5(AGENT_ACTOR_RESOLVER3)),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
+    typeof AgentService === "undefined" ? Object : AgentService,
+    typeof ActorResolver === "undefined" ? Object : ActorResolver
+  ])
+], ThreadsController);
+
+// src/controller/tool-call.controller.ts
+import { AGENT_ACTOR_RESOLVER as AGENT_ACTOR_RESOLVER4 } from "@dudousxd/nestjs-agent-core";
+import { Body as Body2, Controller as Controller4, Inject as Inject6, Post as Post3, Req as Req4 } from "@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_metadata6(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata6, "_ts_metadata");
+function _ts_param6(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param6, "_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_decorate6([
+  Post3("approve"),
+  _ts_param6(0, Req4()),
+  _ts_param6(1, Body2()),
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("design:paramtypes", [
+    typeof Request === "undefined" ? Object : Request,
+    typeof ApproveBody === "undefined" ? Object : ApproveBody
+  ]),
+  _ts_metadata6("design:returntype", Promise)
+], ToolCallController.prototype, "approve", null);
+_ts_decorate6([
+  Post3("reject"),
+  _ts_param6(0, Req4()),
+  _ts_param6(1, Body2()),
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("design:paramtypes", [
+    typeof Request === "undefined" ? Object : Request,
+    typeof RejectBody === "undefined" ? Object : RejectBody
+  ]),
+  _ts_metadata6("design:returntype", Promise)
+], ToolCallController.prototype, "reject", null);
+ToolCallController = _ts_decorate6([
+  Controller4("tool-call"),
+  _ts_param6(1, Inject6(AGENT_ACTOR_RESOLVER4)),
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("design:paramtypes", [
+    typeof AgentService === "undefined" ? Object : AgentService,
+    typeof ActorResolver === "undefined" ? Object : ActorResolver
+  ])
+], ToolCallController);
+
+// src/discovery/ai-tool-discovery.service.ts
+import { AGENT_OPTIONS as AGENT_OPTIONS2, AGENT_REGISTRY as AGENT_REGISTRY2, AGENT_TOOL_REGISTRY as AGENT_TOOL_REGISTRY2 } from "@dudousxd/nestjs-agent-core";
+import { Inject as Inject7, Injectable as Injectable3, Logger } from "@nestjs/common";
+import { DiscoveryService } from "@nestjs/core";
+import { z } from "zod";
+
+// src/decorator/ai-tool.decorator.ts
+import "reflect-metadata";
+var AI_TOOL_METADATA = Symbol("nestjs-agent:ai-tool");
+function AiTool(options) {
+  return (target) => {
+    Reflect.defineMetadata(AI_TOOL_METADATA, options, target);
+  };
+}
+__name(AiTool, "AiTool");
+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 brand(tool) {
+  return {
+    [AGENT_TOOL_BRAND]: true,
+    spec: tool.spec,
+    handler: tool.handler
+  };
+}
+__name(brand, "brand");
+function isBrandedFunctionalTool(value) {
+  return AGENT_TOOL_BRAND in value && "spec" in value && "handler" in value;
+}
+__name(isBrandedFunctionalTool, "isBrandedFunctionalTool");
+function provideAgentTool(factoryOrTool, inject) {
+  const provide = Symbol("nestjs-agent:functional-tool-instance");
+  if (typeof factoryOrTool === "function") {
+    return {
+      provide,
+      useFactory: /* @__PURE__ */ __name((...deps) => brand(factoryOrTool(...deps)), "useFactory"),
+      inject: inject ?? []
+    };
+  }
+  return {
+    provide,
+    useValue: brand(factoryOrTool)
+  };
+}
+__name(provideAgentTool, "provideAgentTool");
+
+// src/discovery/ai-tool-discovery.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") 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_metadata7(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata7, "_ts_metadata");
+function _ts_param7(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param7, "_ts_param");
+var AiToolDiscoveryService = class _AiToolDiscoveryService {
+  static {
+    __name(this, "AiToolDiscoveryService");
+  }
+  discovery;
+  registry;
+  agents;
+  options;
+  logger = new 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: z.object({
+              task: 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_decorate7([
+  Injectable3(),
+  _ts_param7(1, Inject7(AGENT_TOOL_REGISTRY2)),
+  _ts_param7(2, Inject7(AGENT_REGISTRY2)),
+  _ts_param7(3, Inject7(AGENT_OPTIONS2)),
+  _ts_metadata7("design:type", Function),
+  _ts_metadata7("design:paramtypes", [
+    typeof DiscoveryService === "undefined" ? Object : DiscoveryService,
+    typeof ToolRegistry === "undefined" ? Object : ToolRegistry,
+    typeof AgentRegistry === "undefined" ? Object : AgentRegistry,
+    typeof AgentModuleOptions === "undefined" ? Object : AgentModuleOptions
+  ])
+], AiToolDiscoveryService);
+
+// src/in-process-sink.ts
+import { AgentStreamError as AgentStreamError2 } from "@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 AgentStreamError2(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
+import { AGENT_DEPS_FACTORY as AGENT_DEPS_FACTORY2, AGENT_STORE as AGENT_STORE3, QuotaExceededError, publishAgentRunFailed, runAgentLoop } from "@dudousxd/nestjs-agent-core";
+import { Inject as Inject8, Injectable as Injectable4, Logger as Logger2 } from "@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_metadata8(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata8, "_ts_metadata");
+function _ts_param8(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param8, "_ts_param");
+var InlineAgentRunner = class _InlineAgentRunner {
+  static {
+    __name(this, "InlineAgentRunner");
+  }
+  factory;
+  store;
+  logger = new Logger2(_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 runAgentLoop({
+      ...deps,
+      day
+    }, input, hooks).catch(async (error) => {
+      const message = error instanceof Error ? error.message : String(error);
+      const code = error instanceof QuotaExceededError ? "quota_exceeded" : "run_failed";
+      this.logger.error(`agent run ${runId} failed (${code}): ${message}`);
+      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 runAgentLoop({
+      ...deps,
+      day
+    }, {
+      threadId: subThread.id,
+      actor,
+      userText: task,
+      agentName,
+      day,
+      delegationDepth: depth,
+      sinkRunId
+    }, hooks);
+  }
+};
+InlineAgentRunner = _ts_decorate8([
+  Injectable4(),
+  _ts_param8(0, Inject8(AGENT_DEPS_FACTORY2)),
+  _ts_param8(1, Inject8(AGENT_STORE3)),
+  _ts_metadata8("design:type", Function),
+  _ts_metadata8("design:paramtypes", [
+    typeof AgentDepsFactory === "undefined" ? Object : AgentDepsFactory,
+    typeof AgentStore === "undefined" ? Object : AgentStore
+  ])
+], InlineAgentRunner);
+
+// src/agent.module.ts
+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");
+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: AGENT_TOOL_REGISTRY3,
+      useFactory: /* @__PURE__ */ __name(() => new ToolRegistry3(), "useFactory")
+    },
+    {
+      provide: AGENT_REGISTRY3,
+      useFactory: /* @__PURE__ */ __name((options) => {
+        const registry = new AgentRegistry3();
+        registry.register(defaultDefinition(options));
+        return registry;
+      }, "useFactory"),
+      inject: [
+        AGENT_OPTIONS3
+      ]
+    },
+    {
+      provide: AGENT_SINK2,
+      useFactory: /* @__PURE__ */ __name((options) => options.sink ?? new InProcessTokenStreamSink(), "useFactory"),
+      inject: [
+        AGENT_OPTIONS3
+      ]
+    },
+    {
+      provide: AGENT_ROLES_POLICY2,
+      useFactory: /* @__PURE__ */ __name((options) => options.rolesPolicy ?? new DefaultRolesPolicy(options.defaultRoles), "useFactory"),
+      inject: [
+        AGENT_OPTIONS3
+      ]
+    },
+    {
+      provide: AGENT_ACTOR_RESOLVER5,
+      useFactory: /* @__PURE__ */ __name((options) => options.actorResolver, "useFactory"),
+      inject: [
+        AGENT_OPTIONS3
+      ]
+    },
+    {
+      provide: AGENT_MODEL2,
+      useFactory: /* @__PURE__ */ __name((o) => o.model, "useFactory"),
+      inject: [
+        AGENT_OPTIONS3
+      ]
+    },
+    {
+      // 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: AGENT_QUOTA_STORE2,
+      useFactory: /* @__PURE__ */ __name((o, store) => o.quota ?? (o.quotaLimitTokens !== void 0 ? new LedgerQuotaStore(store, o.quotaLimitTokens) : void 0), "useFactory"),
+      inject: [
+        AGENT_OPTIONS3,
+        AGENT_STORE4
+      ]
+    },
+    AgentDepsFactory2,
+    {
+      provide: AGENT_DEPS_FACTORY3,
+      useExisting: AgentDepsFactory2
+    },
+    AiToolDiscoveryService,
+    InlineAgentRunner,
+    AgentService
+  ];
+  if (includeStore) {
+    providers.push({
+      provide: AGENT_STORE4,
+      useFactory: /* @__PURE__ */ __name((o) => o.store, "useFactory"),
+      inject: [
+        AGENT_OPTIONS3
+      ]
+    });
+  }
+  if (durable) {
+    providers.push({
+      provide: AGENT_RUNNER2,
+      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: AGENT_DURABLE_RUNNER,
+          optional: true
+        }
+      ]
+    });
+  } else {
+    providers.push({
+      provide: AGENT_RUNNER2,
+      useExisting: InlineAgentRunner
+    });
+  }
+  return providers;
+}
+__name(sharedProviders, "sharedProviders");
+function exportsFor(includeStore) {
+  return [
+    AGENT_OPTIONS3,
+    AGENT_TOOL_REGISTRY3,
+    AGENT_REGISTRY3,
+    AGENT_SINK2,
+    AGENT_ROLES_POLICY2,
+    AGENT_ACTOR_RESOLVER5,
+    AGENT_MODEL2,
+    ...includeStore ? [
+      AGENT_STORE4
+    ] : [],
+    AGENT_QUOTA_STORE2,
+    AGENT_DEPS_FACTORY3,
+    AgentDepsFactory2,
+    AgentService,
+    InlineAgentRunner
+  ];
+}
+__name(exportsFor, "exportsFor");
+var CONTROLLERS = [
+  ChatController,
+  ThreadsController,
+  ToolCallController,
+  QuotaController
+];
+function routerFor(path) {
+  return 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: [
+        DiscoveryModule,
+        routerFor(path)
+      ],
+      controllers: CONTROLLERS,
+      providers: [
+        {
+          provide: AGENT_OPTIONS3,
+          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: [
+        DiscoveryModule,
+        routerFor(path),
+        ...options.imports ?? []
+      ],
+      controllers: CONTROLLERS,
+      providers: [
+        {
+          provide: AGENT_OPTIONS3,
+          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: [
+            AGENT_REGISTRY3
+          ]
+        }
+      ]
+    };
+  }
+};
+AgentModule = _ts_decorate9([
+  Global(),
+  Module({})
+], AgentModule);
+
+// src/resolver/header-actor-resolver.ts
+function readHeader(req, name) {
+  if (typeof req !== "object" || req === null || !("headers" in req)) return void 0;
+  const { headers } = req;
+  if (typeof headers !== "object" || headers === null || !(name in headers)) return void 0;
+  const value = Reflect.get(headers, name);
+  return typeof value === "string" ? value : void 0;
+}
+__name(readHeader, "readHeader");
+var HeaderActorResolver = class {
+  static {
+    __name(this, "HeaderActorResolver");
+  }
+  resolve(req) {
+    const id = readHeader(req, "x-actor-id");
+    if (id === void 0 || id.length === 0) {
+      throw new Error("HeaderActorResolver: missing x-actor-id header. No default actor is fabricated. Send x-actor-id from a trusted gateway, or configure AgentModule.forRoot({ actorResolver }) with a resolver that reads your authenticated principal.");
+    }
+    const roles = (readHeader(req, "x-actor-role") ?? "").split(",").map((role) => role.trim()).filter((role) => role.length > 0);
+    const tenantRef = readHeader(req, "x-tenant-ref");
+    return {
+      id,
+      roles,
+      ...tenantRef !== void 0 ? {
+        tenantRef
+      } : {}
+    };
+  }
+};
+
+// src/index.ts
+export * from "@dudousxd/nestjs-agent-core";
+export {
+  AGENT_TOOL_BRAND,
+  AI_TOOL_METADATA,
+  AgentDepsFactory2 as AgentDepsFactory,
+  AgentModule,
+  AgentService,
+  AiTool,
+  AiToolDiscoveryService,
+  HeaderActorResolver,
+  InProcessTokenStreamSink,
+  InlineAgentRunner,
+  LedgerQuotaStore,
+  delegateToolName,
+  provideAgentTool,
+  readAiToolMetadata,
+  utcDay
+};
+//# sourceMappingURL=index.js.map