@dudousxd/nestjs-agent-core 0.1.0

package/dist/index.js

@@ -0,0 +1,753 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/tokens.ts
+var AGENT_OPTIONS = Symbol.for("@dudousxd/nestjs-agent:options");
+var AGENT_STORE = Symbol.for("@dudousxd/nestjs-agent:store");
+var AGENT_RUNNER = Symbol.for("@dudousxd/nestjs-agent:runner");
+var AGENT_DURABLE_RUNNER = Symbol.for("@dudousxd/nestjs-agent:durable-runner");
+var AGENT_SINK = Symbol.for("@dudousxd/nestjs-agent:sink");
+var AGENT_MODEL = Symbol.for("@dudousxd/nestjs-agent:model");
+var AGENT_ROLES_POLICY = Symbol.for("@dudousxd/nestjs-agent:roles-policy");
+var AGENT_QUOTA_STORE = Symbol.for("@dudousxd/nestjs-agent:quota-store");
+var AGENT_TOOL_REGISTRY = Symbol.for("@dudousxd/nestjs-agent:tool-registry");
+var AGENT_REGISTRY = Symbol.for("@dudousxd/nestjs-agent:agent-registry");
+var AGENT_ACTOR_RESOLVER = Symbol.for("@dudousxd/nestjs-agent:actor-resolver");
+var AGENT_GOVERNANCE_QUERIES = Symbol.for("@dudousxd/nestjs-agent:governance-queries");
+var AGENT_PRICING_STORE = Symbol.for("@dudousxd/nestjs-agent:pricing-store");
+var AGENT_RETRIEVER = Symbol.for("@dudousxd/nestjs-agent:retriever");
+var AGENT_EMBEDDING_PROVIDER = Symbol.for("@dudousxd/nestjs-agent:embedding-provider");
+var AGENT_DEPS_FACTORY = Symbol.for("@dudousxd/nestjs-agent:deps-factory");
+
+// src/spi/token-stream-sink.ts
+var AgentStreamError = class extends Error {
+  static {
+    __name(this, "AgentStreamError");
+  }
+  code;
+  constructor(error) {
+    super(error.message);
+    this.name = "AgentStreamError";
+    this.code = error.code;
+  }
+};
+
+// src/spi/pricing-store.ts
+async function seedModelPrices(store, prices) {
+  for (const price of prices) {
+    await store.upsertModelPrice(price);
+  }
+}
+__name(seedModelPrices, "seedModelPrices");
+
+// src/personas.ts
+async function filterToolsByRole(tools, actor, policy) {
+  const checked = await Promise.all(tools.map(async (tool) => ({
+    tool,
+    allowed: await policy.can(actor, tool)
+  })));
+  return checked.filter((entry) => entry.allowed).map((entry) => entry.tool);
+}
+__name(filterToolsByRole, "filterToolsByRole");
+function personaFilterTools(tools, allowedTools) {
+  if (allowedTools === void 0) {
+    return tools;
+  }
+  const allowed = new Set(allowedTools);
+  return tools.filter((tool) => allowed.has(tool.name));
+}
+__name(personaFilterTools, "personaFilterTools");
+
+// src/agent-registry.ts
+var AgentRegistry = class {
+  static {
+    __name(this, "AgentRegistry");
+  }
+  definitions = /* @__PURE__ */ new Map();
+  register(definition) {
+    this.definitions.set(definition.name, definition);
+  }
+  get(name) {
+    return this.definitions.get(name);
+  }
+  has(name) {
+    return this.definitions.has(name);
+  }
+  list() {
+    return [
+      ...this.definitions.values()
+    ];
+  }
+};
+
+// src/tool-registry.ts
+var ToolForbiddenError = class extends Error {
+  static {
+    __name(this, "ToolForbiddenError");
+  }
+  toolName;
+  constructor(toolName) {
+    super(`Tool "${toolName}" is not allowed for this role`), this.toolName = toolName;
+    this.name = "ToolForbiddenError";
+  }
+};
+var ToolNotFoundError = class extends Error {
+  static {
+    __name(this, "ToolNotFoundError");
+  }
+  toolName;
+  constructor(toolName) {
+    super(`Tool "${toolName}" is not registered`), this.toolName = toolName;
+    this.name = "ToolNotFoundError";
+  }
+};
+var ToolInputInvalidError = class extends Error {
+  static {
+    __name(this, "ToolInputInvalidError");
+  }
+  toolName;
+  issues;
+  constructor(toolName, issues) {
+    super(`Invalid input for tool "${toolName}": ${issues.map((issue) => issue.message).join("; ")}`), this.toolName = toolName, this.issues = issues;
+    this.name = "ToolInputInvalidError";
+  }
+};
+var ToolRegistry = class {
+  static {
+    __name(this, "ToolRegistry");
+  }
+  entries = /* @__PURE__ */ new Map();
+  register(spec, handler) {
+    this.entries.set(spec.name, {
+      spec,
+      handler
+    });
+  }
+  has(name) {
+    return this.entries.has(name);
+  }
+  spec(name) {
+    return this.entries.get(name)?.spec;
+  }
+  allSpecs() {
+    return [
+      ...this.entries.values()
+    ].map((entry) => entry.spec);
+  }
+  /** The tools to offer the model for this actor+persona, after the two filter layers. */
+  async definitionsFor(actor, policy, allowedTools) {
+    const roleScoped = await filterToolsByRole(this.allSpecs(), actor, policy);
+    const personaScoped = personaFilterTools(roleScoped, allowedTools);
+    return personaScoped.map((spec) => ({
+      name: spec.name,
+      kind: spec.kind,
+      description: spec.description,
+      inputSchema: spec.inputSchema
+    }));
+  }
+  /** Run a tool. Re-checks the role (defense-in-depth) and re-parses the input via Zod. */
+  async invoke(name, input, ctx, policy) {
+    const entry = this.entries.get(name);
+    if (entry === void 0) {
+      throw new ToolNotFoundError(name);
+    }
+    if (!await policy.can(ctx.actor, entry.spec)) {
+      throw new ToolForbiddenError(name);
+    }
+    const validation = await entry.spec.inputSchema["~standard"].validate(input);
+    if (validation.issues !== void 0) {
+      throw new ToolInputInvalidError(name, validation.issues);
+    }
+    return entry.handler.execute(validation.value, ctx);
+  }
+};
+var DefaultRolesPolicy = class {
+  static {
+    __name(this, "DefaultRolesPolicy");
+  }
+  defaultRoles;
+  constructor(defaultRoles = [
+    "ADMIN"
+  ]) {
+    this.defaultRoles = defaultRoles;
+  }
+  can(actor, tool) {
+    const allowed = tool.roles ?? this.defaultRoles;
+    return (actor.roles ?? []).some((role) => allowed.includes(role));
+  }
+};
+
+// src/diagnostics.ts
+import { emit } from "@dudousxd/nestjs-diagnostics";
+function publishAgentRunStarted(payload) {
+  emit("agent", "run.started", payload);
+}
+__name(publishAgentRunStarted, "publishAgentRunStarted");
+function publishAgentMessage(payload) {
+  emit("agent", "message", payload);
+}
+__name(publishAgentMessage, "publishAgentMessage");
+function publishAgentToolCall(payload) {
+  emit("agent", "tool-call", payload);
+}
+__name(publishAgentToolCall, "publishAgentToolCall");
+function publishAgentQuotaExceeded(payload) {
+  emit("agent", "quota.exceeded", payload);
+}
+__name(publishAgentQuotaExceeded, "publishAgentQuotaExceeded");
+function publishAgentRunFinished(payload) {
+  emit("agent", "run.finished", payload);
+}
+__name(publishAgentRunFinished, "publishAgentRunFinished");
+function publishAgentRunFailed(payload) {
+  emit("agent", "run.failed", payload);
+}
+__name(publishAgentRunFailed, "publishAgentRunFailed");
+function publishAgentDelegated(payload) {
+  emit("agent", "delegated", payload);
+}
+__name(publishAgentDelegated, "publishAgentDelegated");
+function publishAgentRetrieved(payload) {
+  emit("agent", "retrieved", payload);
+}
+__name(publishAgentRetrieved, "publishAgentRetrieved");
+
+// src/agent-loop.ts
+function buildContextBlock(passages) {
+  const items = passages.map((passage, index) => {
+    const label = passage.source !== void 0 ? ` (${passage.source})` : "";
+    return `[${index + 1}]${label} ${passage.text}`;
+  }).join("\n\n");
+  return `<retrieved_context>
+${items}
+</retrieved_context>
+Use the retrieved context above to answer when relevant, and cite sources by their bracket number.`;
+}
+__name(buildContextBlock, "buildContextBlock");
+function intersectAllow(a, b) {
+  if (a === void 0) {
+    return b;
+  }
+  if (b === void 0) {
+    return a;
+  }
+  const second = new Set(b);
+  return a.filter((name) => second.has(name));
+}
+__name(intersectAllow, "intersectAllow");
+var QuotaExceededError = class extends Error {
+  static {
+    __name(this, "QuotaExceededError");
+  }
+  constructor() {
+    super("Daily token quota exceeded");
+    this.name = "QuotaExceededError";
+  }
+};
+var MAX_DELEGATION_DEPTH = 5;
+async function resolvePrompt(prompt, ctx) {
+  return typeof prompt === "function" ? prompt(ctx) : prompt;
+}
+__name(resolvePrompt, "resolvePrompt");
+async function resolveSystemPrompt(deps, input) {
+  const base = {
+    actor: input.actor,
+    ...input.persona !== void 0 ? {
+      persona: input.persona
+    } : {},
+    ...input.pageContext !== void 0 ? {
+      pageContext: input.pageContext
+    } : {}
+  };
+  const basePrompt = await resolvePrompt(deps.systemPrompt, {
+    ...base,
+    basePrompt: ""
+  });
+  if (input.persona === void 0) {
+    return basePrompt;
+  }
+  return resolvePrompt(input.persona.systemPrompt, {
+    ...base,
+    basePrompt
+  });
+}
+__name(resolveSystemPrompt, "resolveSystemPrompt");
+function extractTask(input) {
+  if (typeof input === "object" && input !== null && "task" in input) {
+    const task = input.task;
+    if (typeof task === "string") {
+      return task;
+    }
+  }
+  return JSON.stringify(input);
+}
+__name(extractTask, "extractTask");
+function deriveTitle(userText) {
+  const trimmed = userText.trim().replace(/\s+/g, " ");
+  return trimmed.length > 60 ? `${trimmed.slice(0, 57)}...` : trimmed || "New chat";
+}
+__name(deriveTitle, "deriveTitle");
+var ToolTimeoutError = class ToolTimeoutError2 extends Error {
+  static {
+    __name(this, "ToolTimeoutError");
+  }
+  constructor(toolName, ms) {
+    super(`Tool "${toolName}" exceeded its ${ms}ms timeout`);
+    this.name = "ToolTimeoutError";
+  }
+};
+function withTimeout(work, ms, toolName) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new ToolTimeoutError(toolName, ms)), ms);
+    work.then((value) => {
+      clearTimeout(timer);
+      resolve(value);
+    }, (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+  });
+}
+__name(withTimeout, "withTimeout");
+function parseFollowUps(text, count) {
+  const source = text.match(/\[[\s\S]*\]/)?.[0] ?? text;
+  try {
+    const parsed = JSON.parse(source);
+    if (Array.isArray(parsed)) {
+      return parsed.filter((item) => typeof item === "string").slice(0, count);
+    }
+  } catch {
+  }
+  return [];
+}
+__name(parseFollowUps, "parseFollowUps");
+async function generateFollowUps(model, messages, count) {
+  const discard = {
+    write: /* @__PURE__ */ __name(() => {
+    }, "write"),
+    end: /* @__PURE__ */ __name(() => {
+    }, "end"),
+    fail: /* @__PURE__ */ __name(() => {
+    }, "fail")
+  };
+  const turn = await model.runTurn({
+    system: `Based on the conversation so far, propose up to ${count} short, distinct follow-up questions the user is likely to ask next. Respond with ONLY a JSON array of strings \u2014 no prose, no code fences.`,
+    messages,
+    tools: [],
+    sink: discard
+  });
+  return {
+    followUps: parseFollowUps(turn.text, count),
+    usage: turn.usage,
+    ...turn.modelId !== void 0 ? {
+      modelId: turn.modelId
+    } : {}
+  };
+}
+__name(generateFollowUps, "generateFollowUps");
+async function runAgentLoop(deps, input, hooks) {
+  const maxSteps = deps.maxSteps ?? 8;
+  const persona = input.persona;
+  let system = await resolveSystemPrompt(deps, input);
+  if (deps.quota !== void 0) {
+    const quota = deps.quota;
+    const state = await hooks.step("quota:check", () => quota.check(input.actor.id, deps.day));
+    if (!state.withinLimit) {
+      publishAgentQuotaExceeded({
+        actorId: input.actor.id,
+        usedTokens: state.usedTokens,
+        limitTokens: state.limitTokens
+      });
+      throw new QuotaExceededError();
+    }
+  }
+  if (input.regenerate === true) {
+    await hooks.step("regenerate:truncate", async () => {
+      const existing = await deps.store.getThread(input.threadId);
+      const messages = existing?.messages ?? [];
+      let lastUserIndex = -1;
+      for (let index = messages.length - 1; index >= 0; index -= 1) {
+        if (messages[index]?.role === "user") {
+          lastUserIndex = index;
+          break;
+        }
+      }
+      const firstDropped = messages[lastUserIndex + 1];
+      if (firstDropped !== void 0) {
+        await deps.store.truncateFrom(input.threadId, firstDropped.id);
+      }
+    });
+  } else {
+    await hooks.step("persist:user", () => deps.store.appendMessage({
+      threadId: input.threadId,
+      role: "user",
+      content: input.userText,
+      ...persona !== void 0 ? {
+        persona: persona.id
+      } : {}
+    }));
+  }
+  const thread = await hooks.step("load:thread", () => deps.store.getThread(input.threadId));
+  const modelMessages = (thread?.messages ?? []).map((message) => ({
+    role: message.role,
+    content: message.content,
+    ...message.toolCalls !== void 0 ? {
+      toolCalls: message.toolCalls
+    } : {},
+    ...message.toolResults !== void 0 ? {
+      toolResults: message.toolResults
+    } : {}
+  }));
+  const writer = await hooks.openSink();
+  let lastText = "";
+  let steps = 0;
+  let totalInput = 0;
+  let totalOutput = 0;
+  publishAgentRunStarted({
+    runId: hooks.runId,
+    threadId: input.threadId,
+    actorId: input.actor.id,
+    ...persona !== void 0 ? {
+      persona: persona.id
+    } : {}
+  });
+  let injectedPassages;
+  if (deps.retriever !== void 0) {
+    const retriever = deps.retriever;
+    const passages = await hooks.step("retrieve", () => retriever.retrieve(input.userText, {
+      topK: deps.retrievalTopK ?? 5
+    }));
+    if (passages.length > 0) {
+      injectedPassages = passages;
+      system = `${system}
+
+${buildContextBlock(passages)}`;
+    }
+    publishAgentRetrieved({
+      runId: hooks.runId,
+      query: input.userText,
+      count: passages.length
+    });
+  }
+  for (let i = 0; i < maxSteps; i += 1) {
+    const tools = await deps.registry.definitionsFor(input.actor, deps.rolesPolicy, intersectAllow(persona?.allowedTools, deps.toolAllowList));
+    const turn = await hooks.step(`llm:${i}`, () => deps.model.runTurn({
+      system,
+      messages: modelMessages,
+      tools,
+      sink: writer
+    }));
+    await hooks.step(`persist:usage:${i}`, () => deps.store.recordUsage({
+      threadId: input.threadId,
+      actorRef: input.actor.id,
+      // provider-reported model wins over the configured fallback, so cost can't misattribute
+      modelId: turn.modelId ?? deps.modelId ?? "unknown",
+      purpose: "chat",
+      usage: turn.usage,
+      // persist the provider's actual cost when reported; the read-model prefers it over pricing
+      ...turn.costUsd !== void 0 ? {
+        costUsd: turn.costUsd
+      } : {}
+    }));
+    if (deps.quota !== void 0) {
+      const quota = deps.quota;
+      await hooks.step(`quota:bump:${i}`, () => quota.bump(input.actor.id, deps.day, turn.usage.inputTokens + turn.usage.outputTokens));
+    }
+    steps += 1;
+    totalInput += turn.usage.inputTokens;
+    totalOutput += turn.usage.outputTokens;
+    lastText = turn.text;
+    publishAgentMessage({
+      runId: hooks.runId,
+      threadId: input.threadId,
+      role: "assistant",
+      textLength: turn.text.length
+    });
+    const isFinalTurn = turn.toolCalls.length === 0;
+    let followUps;
+    if (isFinalTurn && deps.followUpsCount !== void 0 && deps.followUpsCount > 0) {
+      const count = deps.followUpsCount;
+      const generated = await hooks.step(`followups:${i}`, () => generateFollowUps(deps.model, [
+        ...modelMessages,
+        {
+          role: "assistant",
+          content: turn.text
+        }
+      ], count));
+      if (generated.followUps.length > 0) {
+        followUps = generated.followUps;
+      }
+      await hooks.step(`persist:usage:followups:${i}`, () => deps.store.recordUsage({
+        threadId: input.threadId,
+        actorRef: input.actor.id,
+        modelId: generated.modelId ?? deps.modelId ?? "unknown",
+        purpose: "follow_ups",
+        usage: generated.usage
+      }));
+    }
+    const assistant = await hooks.step(`persist:assistant:${i}`, () => deps.store.appendMessage({
+      threadId: input.threadId,
+      role: "assistant",
+      content: turn.text,
+      usage: turn.usage,
+      ...persona !== void 0 ? {
+        persona: persona.id
+      } : {},
+      ...turn.toolCalls.length > 0 ? {
+        toolCalls: turn.toolCalls
+      } : {},
+      ...followUps !== void 0 ? {
+        followUps
+      } : {}
+    }));
+    modelMessages.push({
+      role: "assistant",
+      content: turn.text,
+      ...turn.toolCalls.length > 0 ? {
+        toolCalls: turn.toolCalls
+      } : {}
+    });
+    if (i === 0 && injectedPassages !== void 0) {
+      const passages = injectedPassages;
+      const toolCallId = `retrieve-${assistant.id}`;
+      await hooks.step(`persist:retrieval:${assistant.id}`, async () => {
+        await deps.store.recordToolCall({
+          toolCallId,
+          messageId: assistant.id,
+          toolName: "retrieve",
+          toolType: "read",
+          input: {
+            query: input.userText
+          },
+          status: "auto_executed"
+        });
+        await deps.store.updateToolCall({
+          toolCallId,
+          status: "executed",
+          output: {
+            passages
+          }
+        });
+      });
+    }
+    if (isFinalTurn) {
+      break;
+    }
+    const results = [];
+    for (const call of turn.toolCalls) {
+      const spec = deps.registry.spec(call.name);
+      const toolType = spec?.kind ?? "read";
+      const ctx = {
+        actor: input.actor,
+        threadId: input.threadId,
+        runId: hooks.runId,
+        requestId: hooks.runId,
+        ...persona !== void 0 ? {
+          persona
+        } : {},
+        ...input.pageContext !== void 0 ? {
+          pageContext: input.pageContext
+        } : {},
+        ...deps.host !== void 0 ? {
+          host: deps.host
+        } : {}
+      };
+      if (toolType === "agent") {
+        const targetAgent = spec?.targetAgent ?? call.name;
+        const task = extractTask(call.input);
+        await hooks.step(`persist:toolcall:${call.id}`, () => deps.store.recordToolCall({
+          toolCallId: call.id,
+          messageId: assistant.id,
+          toolName: call.name,
+          toolType: "read",
+          input: call.input,
+          status: "auto_executed"
+        }));
+        const overDepth = (input.delegationDepth ?? 0) >= MAX_DELEGATION_DEPTH;
+        publishAgentDelegated({
+          runId: hooks.runId,
+          toAgent: targetAgent,
+          ...input.agentName !== void 0 ? {
+            fromAgent: input.agentName
+          } : {}
+        });
+        let sub;
+        if (overDepth) {
+          sub = {
+            text: `(delegation depth limit of ${MAX_DELEGATION_DEPTH} reached)`
+          };
+        } else if (hooks.runAgent) {
+          sub = await hooks.runAgent(targetAgent, task);
+        } else {
+          sub = {
+            text: `(no multi-agent support wired; cannot reach "${targetAgent}")`
+          };
+        }
+        await hooks.step(`persist:toolexec:${call.id}`, () => deps.store.updateToolCall({
+          toolCallId: call.id,
+          status: "executed",
+          output: sub
+        }));
+        results.push({
+          id: call.id,
+          name: call.name,
+          output: sub
+        });
+        continue;
+      }
+      if (toolType === "action") {
+        await hooks.step(`persist:toolcall:${call.id}`, () => deps.store.recordToolCall({
+          toolCallId: call.id,
+          messageId: assistant.id,
+          toolName: call.name,
+          toolType: "action",
+          input: call.input,
+          status: "pending_approval"
+        }));
+        const decision = await hooks.awaitApproval(call, ctx);
+        if (!decision.approved) {
+          await hooks.step(`persist:toolreject:${call.id}`, () => deps.store.updateToolCall({
+            toolCallId: call.id,
+            status: "rejected",
+            ...decision.reason !== void 0 ? {
+              error: decision.reason
+            } : {}
+          }));
+          results.push({
+            id: call.id,
+            name: call.name,
+            output: {
+              rejected: true,
+              reason: decision.reason ?? "rejected by user"
+            },
+            error: "rejected"
+          });
+          publishAgentToolCall({
+            runId: hooks.runId,
+            toolName: call.name,
+            toolType,
+            status: "rejected"
+          });
+          continue;
+        }
+      } else {
+        await hooks.step(`persist:toolcall:${call.id}`, () => deps.store.recordToolCall({
+          toolCallId: call.id,
+          messageId: assistant.id,
+          toolName: call.name,
+          toolType: "read",
+          input: call.input,
+          status: "auto_executed"
+        }));
+      }
+      const startedAt = Date.now();
+      try {
+        const invocation = hooks.step(`tool:${call.id}`, () => deps.registry.invoke(call.name, call.input, ctx, deps.rolesPolicy));
+        const output = deps.toolTimeoutMs !== void 0 ? await withTimeout(invocation, deps.toolTimeoutMs, call.name) : await invocation;
+        const executionMs = Date.now() - startedAt;
+        await hooks.step(`persist:toolexec:${call.id}`, () => deps.store.updateToolCall({
+          toolCallId: call.id,
+          status: "executed",
+          output,
+          executionMs,
+          ...toolType === "action" ? {
+            executedByRef: input.actor.id
+          } : {}
+        }));
+        results.push({
+          id: call.id,
+          name: call.name,
+          output
+        });
+        publishAgentToolCall({
+          runId: hooks.runId,
+          toolName: call.name,
+          toolType,
+          status: "executed",
+          durationMs: executionMs
+        });
+      } catch (error) {
+        const executionMs = Date.now() - startedAt;
+        const message = error instanceof Error ? error.message : String(error);
+        await hooks.step(`persist:toolfail:${call.id}`, () => deps.store.updateToolCall({
+          toolCallId: call.id,
+          status: "failed",
+          error: message,
+          executionMs
+        }));
+        results.push({
+          id: call.id,
+          name: call.name,
+          output: null,
+          error: message
+        });
+        publishAgentToolCall({
+          runId: hooks.runId,
+          toolName: call.name,
+          toolType,
+          status: "failed",
+          durationMs: executionMs
+        });
+      }
+    }
+    modelMessages.push({
+      role: "user",
+      content: "",
+      toolResults: results
+    });
+  }
+  if (thread !== null && (thread.title === "" || thread.title === "New chat")) {
+    await hooks.step("persist:title", () => deps.store.setTitle(input.threadId, deriveTitle(input.userText)));
+  }
+  await writer.end();
+  publishAgentRunFinished({
+    runId: hooks.runId,
+    threadId: input.threadId,
+    steps,
+    inputTokens: totalInput,
+    outputTokens: totalOutput
+  });
+  return {
+    text: lastText
+  };
+}
+__name(runAgentLoop, "runAgentLoop");
+export {
+  AGENT_ACTOR_RESOLVER,
+  AGENT_DEPS_FACTORY,
+  AGENT_DURABLE_RUNNER,
+  AGENT_EMBEDDING_PROVIDER,
+  AGENT_GOVERNANCE_QUERIES,
+  AGENT_MODEL,
+  AGENT_OPTIONS,
+  AGENT_PRICING_STORE,
+  AGENT_QUOTA_STORE,
+  AGENT_REGISTRY,
+  AGENT_RETRIEVER,
+  AGENT_ROLES_POLICY,
+  AGENT_RUNNER,
+  AGENT_SINK,
+  AGENT_STORE,
+  AGENT_TOOL_REGISTRY,
+  AgentRegistry,
+  AgentStreamError,
+  DefaultRolesPolicy,
+  QuotaExceededError,
+  ToolForbiddenError,
+  ToolInputInvalidError,
+  ToolNotFoundError,
+  ToolRegistry,
+  filterToolsByRole,
+  personaFilterTools,
+  publishAgentDelegated,
+  publishAgentMessage,
+  publishAgentQuotaExceeded,
+  publishAgentRetrieved,
+  publishAgentRunFailed,
+  publishAgentRunFinished,
+  publishAgentRunStarted,
+  publishAgentToolCall,
+  runAgentLoop,
+  seedModelPrices
+};
+//# sourceMappingURL=index.js.map