@mgvdev/nestjs-ai 0.1.0

package/dist/testing.js

@@ -0,0 +1,2391 @@
+import { MockLanguageModelV3, MockEmbeddingModelV3 } from 'ai/test';
+import { Test } from '@nestjs/testing';
+import { Injectable, Inject, Optional, Global, Module } from '@nestjs/common';
+import { DiscoveryService, MetadataScanner, Reflector, DiscoveryModule, ModuleRef } from '@nestjs/core';
+import { wrapLanguageModel, tool, generateText, streamText, generateObject, streamObject, embed, embedMany, stepCountIs, generateImage, experimental_generateSpeech, experimental_transcribe, cosineSimilarity, dynamicTool, jsonSchema } from 'ai';
+import { z } from 'zod';
+import 'reflect-metadata';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var ZERO_USAGE = {
+  inputTokens: 0,
+  outputTokens: 0,
+  totalTokens: 0
+};
+function createMockModel(replies) {
+  const texts = Array.isArray(replies) ? replies : [
+    replies
+  ];
+  const results = texts.map((text) => ({
+    content: [
+      {
+        type: "text",
+        text
+      }
+    ],
+    finishReason: "stop",
+    usage: ZERO_USAGE,
+    warnings: []
+  }));
+  let call = 0;
+  return new MockLanguageModelV3({
+    doGenerate: /* @__PURE__ */ __name(async () => results[Math.min(call++, results.length - 1)], "doGenerate")
+  });
+}
+__name(createMockModel, "createMockModel");
+function createEmbeddingMock(embed2) {
+  return new MockEmbeddingModelV3({
+    doEmbed: /* @__PURE__ */ __name(async ({ values }) => ({
+      embeddings: values.map(embed2),
+      usage: {
+        tokens: values.length
+      }
+    }), "doEmbed")
+  });
+}
+__name(createEmbeddingMock, "createEmbeddingMock");
+
+// src/ai.constants.ts
+var AI_MODULE_OPTIONS = /* @__PURE__ */ Symbol("AI_MODULE_OPTIONS");
+var CONVERSATION_STORE = /* @__PURE__ */ Symbol("CONVERSATION_STORE");
+var VECTOR_STORE = /* @__PURE__ */ Symbol("VECTOR_STORE");
+var AI_CACHE = /* @__PURE__ */ Symbol("AI_CACHE");
+var APPROVAL_GATE = /* @__PURE__ */ Symbol("APPROVAL_GATE");
+var RATE_LIMITER = /* @__PURE__ */ Symbol("RATE_LIMITER");
+var RERANKER = /* @__PURE__ */ Symbol("RERANKER");
+var TOOL_METADATA = /* @__PURE__ */ Symbol("nestjs-ai:tool");
+var AGENT_METADATA = /* @__PURE__ */ Symbol("nestjs-ai:agent");
+var GUARDRAIL_METADATA = /* @__PURE__ */ Symbol("nestjs-ai:guardrail");
+var DEFAULT_MAX_STEPS = 5;
+
+// src/resilience/fallback-model.ts
+function createFallbackModel(models, options = {}) {
+  if (models.length === 0) {
+    throw new Error("createFallbackModel requires at least one model.");
+  }
+  const primary = models[0];
+  const shouldRetry = options.shouldRetry ?? (() => true);
+  async function attempt(call) {
+    let lastError;
+    for (let i = 0; i < models.length; i++) {
+      try {
+        return await call(models[i]);
+      } catch (error) {
+        lastError = error;
+        const isLast = i === models.length - 1;
+        if (isLast || !shouldRetry(error)) {
+          throw error;
+        }
+      }
+    }
+    throw lastError;
+  }
+  __name(attempt, "attempt");
+  return {
+    specificationVersion: "v3",
+    provider: options.provider ?? `fallback(${primary.provider})`,
+    modelId: primary.modelId,
+    get supportedUrls() {
+      return primary.supportedUrls;
+    },
+    doGenerate: /* @__PURE__ */ __name((callOptions) => attempt((model) => model.doGenerate(callOptions)), "doGenerate"),
+    doStream: /* @__PURE__ */ __name((callOptions) => attempt((model) => model.doStream(callOptions)), "doStream")
+  };
+}
+__name(createFallbackModel, "createFallbackModel");
+
+// src/cache/cache-middleware.ts
+function createCacheMiddleware(cache, options = {}) {
+  return {
+    async wrapGenerate({ doGenerate, params, model }) {
+      const key = cacheKey(model.modelId, params);
+      const cached = await cache.get(key);
+      if (cached !== void 0) {
+        return cached;
+      }
+      const result = await doGenerate();
+      await cache.set(key, result, options.ttlMs);
+      return result;
+    }
+  };
+}
+__name(createCacheMiddleware, "createCacheMiddleware");
+function cacheKey(modelId, params) {
+  return `${modelId}:${stableStringify(params)}`;
+}
+__name(cacheKey, "cacheKey");
+function stableStringify(value) {
+  return JSON.stringify(value, (_key, val) => {
+    if (val && typeof val === "object" && !Array.isArray(val)) {
+      return Object.keys(val).sort().reduce((acc, k) => {
+        acc[k] = val[k];
+        return acc;
+      }, {});
+    }
+    return val;
+  });
+}
+__name(stableStringify, "stableStringify");
+
+// src/core/provider-registry.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 ProviderRegistry = class {
+  static {
+    __name(this, "ProviderRegistry");
+  }
+  options;
+  cache;
+  providers = /* @__PURE__ */ new Map();
+  constructor(options, cache) {
+    this.options = options;
+    this.cache = cache;
+  }
+  /** Wraps a model with the cache middleware when a cache is configured. */
+  applyCache(model) {
+    if (!this.cache || typeof model === "string") {
+      return model;
+    }
+    return wrapLanguageModel({
+      model,
+      middleware: createCacheMiddleware(this.cache, {
+        ttlMs: this.options.cacheTtlMs
+      })
+    });
+  }
+  async onModuleInit() {
+    const configured = this.options.providers ?? {};
+    for (const name of Object.keys(configured)) {
+      const config = configured[name];
+      if (config) {
+        await this.initProvider(name, config);
+      }
+    }
+  }
+  /**
+  * Resolves a language model. Accepts a `LanguageModel` instance (returned
+  * as-is), a `"provider:model"` string, a bare `"model"` string (using the
+  * default provider), or `undefined` (using `defaultModel`).
+  */
+  getLanguageModel(model) {
+    const chain = model ?? this.options.defaultModel;
+    if (Array.isArray(chain)) {
+      if (chain.length === 0) {
+        throw new Error("An empty model array was provided.");
+      }
+      if (chain.length === 1) {
+        return this.getLanguageModel(chain[0]);
+      }
+      const resolved = chain.map((m) => this.resolveSingle(m));
+      return this.applyCache(createFallbackModel(resolved));
+    }
+    return this.applyCache(this.resolveSingle(chain));
+  }
+  /** Resolves a single (non-array) model reference without cache wrapping. */
+  resolveSingle(model) {
+    if (model && typeof model !== "string") {
+      return model;
+    }
+    const { provider, modelId } = this.resolve(model, void 0);
+    return provider.languageModel(modelId);
+  }
+  /**
+  * Resolves an embedding model from a `"provider:model"` string, a bare model
+  * string, an `EmbeddingModel` instance, or `undefined` (using
+  * `defaultEmbeddingModel`).
+  */
+  getEmbeddingModel(model) {
+    if (model && typeof model !== "string") {
+      return model;
+    }
+    const { name, provider, modelId } = this.resolve(model, this.options.defaultEmbeddingModel);
+    if (typeof provider.textEmbeddingModel !== "function") {
+      throw new Error(`Provider "${name}" does not support embeddings. Configure a provider with embedding support (e.g. openai or google).`);
+    }
+    return provider.textEmbeddingModel(modelId);
+  }
+  /** Resolves an image-generation model (default `defaultImageModel`). */
+  getImageModel(model) {
+    if (model && typeof model !== "string") {
+      return model;
+    }
+    return this.resolveMultimodal(model, this.options.defaultImageModel, [
+      "imageModel",
+      "image"
+    ], "image generation");
+  }
+  /** Resolves a reranking model (default `rerankingModel` option). */
+  getRerankingModel(model) {
+    if (model && typeof model !== "string") {
+      return model;
+    }
+    return this.resolveMultimodal(model, this.options.rerankingModel, [
+      "rerankingModel",
+      "reranking"
+    ], "reranking");
+  }
+  /** Resolves a speech (text-to-speech) model (default `defaultSpeechModel`). */
+  getSpeechModel(model) {
+    if (model && typeof model !== "string") {
+      return model;
+    }
+    return this.resolveMultimodal(model, this.options.defaultSpeechModel, [
+      "speechModel",
+      "speech"
+    ], "speech");
+  }
+  /** Resolves a transcription (speech-to-text) model. */
+  getTranscriptionModel(model) {
+    if (model && typeof model !== "string") {
+      return model;
+    }
+    return this.resolveMultimodal(model, this.options.defaultTranscriptionModel, [
+      "transcriptionModel",
+      "transcription"
+    ], "transcription");
+  }
+  /**
+  * Shared resolution for multimodal models: resolves the provider, then calls
+  * the first available factory method (standard name, then shorthand).
+  */
+  resolveMultimodal(model, fallback, methods, capability) {
+    const { name, provider, modelId } = this.resolve(model, fallback);
+    for (const method of methods) {
+      const fn = provider[method];
+      if (typeof fn === "function") {
+        return fn.call(provider, modelId);
+      }
+    }
+    throw new Error(`Provider "${name}" does not support ${capability}. Configure a provider that does (e.g. openai).`);
+  }
+  resolve(model, fallback) {
+    const raw = model ?? fallback;
+    if (!raw) {
+      throw new Error("No model specified and no default model configured. Pass a model id or set `defaultModel` in AiModule options.");
+    }
+    const name = this.parseProviderName(raw);
+    const modelId = this.parseModelId(raw);
+    const provider = this.providers.get(name);
+    if (!provider) {
+      throw new Error(`Provider "${name}" is not configured. Add it to AiModule \`providers\` options and install \`@ai-sdk/${name}\`.`);
+    }
+    return {
+      name,
+      provider,
+      modelId
+    };
+  }
+  parseProviderName(raw) {
+    const sep = raw.indexOf(":");
+    if (sep !== -1) {
+      return raw.slice(0, sep);
+    }
+    if (this.providers.size === 1) {
+      return this.providers.keys().next().value;
+    }
+    const def = this.options.defaultModel;
+    if (def && def.includes(":")) {
+      return def.slice(0, def.indexOf(":"));
+    }
+    throw new Error(`Cannot infer provider for model "${raw}". Prefix it as "provider:model" (e.g. "openai:${raw}").`);
+  }
+  parseModelId(raw) {
+    const sep = raw.indexOf(":");
+    return sep !== -1 ? raw.slice(sep + 1) : raw;
+  }
+  async initProvider(name, config) {
+    const settings = {
+      apiKey: config.apiKey,
+      baseURL: config.baseURL,
+      headers: config.headers
+    };
+    try {
+      switch (name) {
+        case "openai": {
+          const { createOpenAI } = await import('@ai-sdk/openai');
+          this.providers.set(name, createOpenAI(settings));
+          break;
+        }
+        case "anthropic": {
+          const { createAnthropic } = await import('@ai-sdk/anthropic');
+          this.providers.set(name, createAnthropic(settings));
+          break;
+        }
+        case "google": {
+          const { createGoogleGenerativeAI } = await import('@ai-sdk/google');
+          this.providers.set(name, createGoogleGenerativeAI(settings));
+          break;
+        }
+        default: {
+          throw new Error(`Unknown provider "${name}".`);
+        }
+      }
+    } catch (error) {
+      if (error instanceof Error && /Cannot find|find module/i.test(error.message)) {
+        throw new Error(`Provider "${name}" is configured but the package "@ai-sdk/${name}" is not installed. Run \`npm install @ai-sdk/${name}\`.`);
+      }
+      throw error;
+    }
+  }
+};
+ProviderRegistry = _ts_decorate([
+  Injectable(),
+  _ts_param(0, Inject(AI_MODULE_OPTIONS)),
+  _ts_param(1, Optional()),
+  _ts_param(1, Inject(AI_CACHE)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof AiModuleOptions === "undefined" ? Object : AiModuleOptions,
+    typeof AiCache === "undefined" ? Object : AiCache
+  ])
+], ProviderRegistry);
+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 EVENT_EMITTER = /* @__PURE__ */ Symbol("AI_EVENT_EMITTER");
+var AiEventEmitter = class {
+  static {
+    __name(this, "AiEventEmitter");
+  }
+  emitter;
+  constructor(emitter) {
+    this.emitter = emitter;
+  }
+  emit(event, payload) {
+    this.emitter?.emit(event, payload);
+  }
+  /** Whether an underlying emitter is wired up. */
+  get enabled() {
+    return this.emitter != null;
+  }
+};
+AiEventEmitter = _ts_decorate2([
+  Injectable(),
+  _ts_param2(0, Optional()),
+  _ts_param2(0, Inject(EVENT_EMITTER)),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    Object
+  ])
+], AiEventEmitter);
+
+// src/observability/ai-events.ts
+var AI_EVENTS = {
+  agentRunStart: "ai.agent.run.start",
+  agentRunFinish: "ai.agent.run.finish",
+  agentRunError: "ai.agent.run.error",
+  toolCall: "ai.tool.call",
+  toolResult: "ai.tool.result",
+  streamFinish: "ai.stream.finish",
+  usage: "ai.usage"
+};
+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");
+var GuardrailRegistry = class {
+  static {
+    __name(this, "GuardrailRegistry");
+  }
+  discovery;
+  guardrails = [];
+  constructor(discovery) {
+    this.discovery = discovery;
+  }
+  onModuleInit() {
+    for (const wrapper of this.discovery.getProviders()) {
+      const instance = wrapper.instance;
+      const ctor = instance?.constructor;
+      if (instance && ctor && Reflect.getMetadata(GUARDRAIL_METADATA, ctor) === true) {
+        this.guardrails.push(instance);
+      }
+    }
+  }
+  get count() {
+    return this.guardrails.length;
+  }
+  async runBeforeRun(ctx) {
+    for (const guardrail of this.guardrails) {
+      await guardrail.beforeRun?.(ctx);
+    }
+  }
+  async runAfterRun(ctx, result) {
+    for (const guardrail of this.guardrails) {
+      await guardrail.afterRun?.(ctx, result);
+    }
+  }
+  async runOnToolCall(tool3, args) {
+    for (const guardrail of this.guardrails) {
+      await guardrail.onToolCall?.(tool3, args);
+    }
+  }
+};
+GuardrailRegistry = _ts_decorate3([
+  Injectable(),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof DiscoveryService === "undefined" ? Object : DiscoveryService
+  ])
+], GuardrailRegistry);
+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");
+var AgentRegistry = class {
+  static {
+    __name(this, "AgentRegistry");
+  }
+  discovery;
+  agents = /* @__PURE__ */ new Map();
+  constructor(discovery) {
+    this.discovery = discovery;
+  }
+  onModuleInit() {
+    for (const wrapper of this.discovery.getProviders()) {
+      const instance = wrapper.instance;
+      const ctor = instance?.constructor;
+      if (instance && ctor && Reflect.getMetadata(AGENT_METADATA, ctor)) {
+        this.agents.set(ctor.name, {
+          name: ctor.name,
+          instance,
+          target: ctor
+        });
+      }
+    }
+  }
+  /** Returns an agent instance by class name. */
+  get(name) {
+    return this.agents.get(name)?.instance;
+  }
+  /** Returns an agent instance by its class. */
+  getByClass(target) {
+    return this.agents.get(target.name)?.instance;
+  }
+  /** All discovered agents. */
+  all() {
+    return [
+      ...this.agents.values()
+    ];
+  }
+};
+AgentRegistry = _ts_decorate4([
+  Injectable(),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
+    typeof DiscoveryService === "undefined" ? Object : DiscoveryService
+  ])
+], AgentRegistry);
+function createAgentTool(agent, options = {}) {
+  const schema = options.inputSchema ?? z.object({
+    input: z.string().describe("The task or question for the agent")
+  });
+  return tool({
+    description: options.description ?? `Delegate the task to the ${options.name ?? "sub"} agent.`,
+    inputSchema: schema,
+    execute: /* @__PURE__ */ __name(async (args) => {
+      const input = typeof args === "string" ? args : args?.input ?? JSON.stringify(args);
+      const result = await agent.run(input);
+      return result.text;
+    }, "execute")
+  });
+}
+__name(createAgentTool, "createAgentTool");
+
+// src/approval/approval-gate.interface.ts
+var ToolApprovalDeniedError = class extends Error {
+  static {
+    __name(this, "ToolApprovalDeniedError");
+  }
+  tool;
+  constructor(tool3) {
+    super(`Tool "${tool3}" was denied by the approval gate.`), this.tool = tool3;
+    this.name = "ToolApprovalDeniedError";
+  }
+};
+
+// src/tools/tool.registry.ts
+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_param3(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param3, "_ts_param");
+var ToolRegistry = class {
+  static {
+    __name(this, "ToolRegistry");
+  }
+  discovery;
+  scanner;
+  reflector;
+  events;
+  guardrails;
+  approvalGate;
+  agentRegistry;
+  tools = /* @__PURE__ */ new Map();
+  constructor(discovery, scanner, reflector, events, guardrails, approvalGate, agentRegistry) {
+    this.discovery = discovery;
+    this.scanner = scanner;
+    this.reflector = reflector;
+    this.events = events;
+    this.guardrails = guardrails;
+    this.approvalGate = approvalGate;
+    this.agentRegistry = agentRegistry;
+  }
+  onModuleInit() {
+    for (const wrapper of this.discovery.getProviders()) {
+      const instance = wrapper.instance;
+      if (!instance || typeof instance !== "object") {
+        continue;
+      }
+      const prototype = Object.getPrototypeOf(instance);
+      if (!prototype) {
+        continue;
+      }
+      for (const methodName of this.scanner.getAllMethodNames(prototype)) {
+        const methodRef = instance[methodName];
+        const metadata = this.reflector.get(TOOL_METADATA, methodRef);
+        if (!metadata) {
+          continue;
+        }
+        this.register(instance, methodName, metadata);
+      }
+    }
+  }
+  register(instance, methodName, metadata) {
+    const name = metadata.name ?? methodName;
+    if (this.tools.has(name)) {
+      throw new Error(`Duplicate AI tool name "${name}". Tool names must be unique across all providers (declared on ${instance.constructor?.name}).`);
+    }
+    const built = tool({
+      description: metadata.description,
+      inputSchema: metadata.schema,
+      execute: /* @__PURE__ */ __name(async (args, opts) => {
+        if (metadata.requiresApproval && this.approvalGate) {
+          const approved = await this.approvalGate.requestApproval({
+            tool: name,
+            args
+          });
+          if (!approved) {
+            throw new ToolApprovalDeniedError(name);
+          }
+        }
+        await this.guardrails?.runOnToolCall(name, args);
+        this.events?.emit(AI_EVENTS.toolCall, {
+          tool: name,
+          args
+        });
+        const result = await instance[methodName](args, opts);
+        this.events?.emit(AI_EVENTS.toolResult, {
+          tool: name,
+          args,
+          result
+        });
+        return result;
+      }, "execute")
+    });
+    this.tools.set(name, {
+      name,
+      tool: built,
+      target: instance.constructor
+    });
+  }
+  /** Returns the tool registered under `name`, if any. */
+  getByName(name) {
+    return this.tools.get(name);
+  }
+  /** Returns every tool declared by the given provider class. */
+  getForClass(target) {
+    return [
+      ...this.tools.values()
+    ].filter((entry) => entry.target === target);
+  }
+  /** Returns all discovered tools. */
+  getAll() {
+    return [
+      ...this.tools.values()
+    ];
+  }
+  /**
+  * Builds the `ToolSet` passed to `generateText`/`streamText` from a list of
+  * tool references (provider classes and/or tool names). Passing no refs
+  * returns every discovered tool.
+  */
+  buildToolSet(refs) {
+    const entries = refs && refs.length > 0 ? refs.flatMap((ref) => this.resolveRef(ref)) : this.getAll();
+    const set = {};
+    for (const entry of entries) {
+      set[entry.name] = entry.tool;
+    }
+    return set;
+  }
+  resolveRef(ref) {
+    if (typeof ref === "string") {
+      const entry = this.getByName(ref);
+      if (!entry) {
+        throw new Error(`Unknown AI tool "${ref}".`);
+      }
+      return [
+        entry
+      ];
+    }
+    const entries = this.getForClass(ref);
+    if (entries.length > 0) {
+      return entries;
+    }
+    const agentEntry = this.resolveAgentRef(ref);
+    if (agentEntry) {
+      return [
+        agentEntry
+      ];
+    }
+    throw new Error(`Class "${ref.name}" declares no @Tool methods and is not a registered @Agent, or was not registered as a provider so it could be discovered.`);
+  }
+  resolveAgentRef(ref) {
+    if (!this.agentRegistry || !Reflect.getMetadata(AGENT_METADATA, ref)) {
+      return void 0;
+    }
+    const instance = this.agentRegistry.getByClass(ref);
+    if (!instance) {
+      return void 0;
+    }
+    return {
+      name: ref.name,
+      tool: createAgentTool(instance, {
+        name: ref.name
+      }),
+      target: ref
+    };
+  }
+};
+ToolRegistry = _ts_decorate5([
+  Injectable(),
+  _ts_param3(3, Optional()),
+  _ts_param3(4, Optional()),
+  _ts_param3(5, Optional()),
+  _ts_param3(5, Inject(APPROVAL_GATE)),
+  _ts_param3(6, Optional()),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
+    typeof DiscoveryService === "undefined" ? Object : DiscoveryService,
+    typeof MetadataScanner === "undefined" ? Object : MetadataScanner,
+    typeof Reflector === "undefined" ? Object : Reflector,
+    typeof AiEventEmitter === "undefined" ? Object : AiEventEmitter,
+    typeof GuardrailRegistry === "undefined" ? Object : GuardrailRegistry,
+    typeof ApprovalGate === "undefined" ? Object : ApprovalGate,
+    typeof AgentRegistry === "undefined" ? Object : AgentRegistry
+  ])
+], ToolRegistry);
+
+// src/core/ai.service.ts
+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");
+var AiService = class {
+  static {
+    __name(this, "AiService");
+  }
+  providers;
+  toolRegistry;
+  constructor(providers, toolRegistry) {
+    this.providers = providers;
+    this.toolRegistry = toolRegistry;
+  }
+  generateText(params) {
+    return generateText(this.resolve(params));
+  }
+  streamText(params) {
+    return streamText(this.resolve(params));
+  }
+  generateObject(params) {
+    return generateObject(this.resolve(params));
+  }
+  streamObject(params) {
+    return streamObject(this.resolve(params));
+  }
+  resolve(params) {
+    const { model, tools, ...rest } = params;
+    return {
+      ...rest,
+      model: this.providers.getLanguageModel(model),
+      ...tools ? {
+        tools: this.toolRegistry.buildToolSet(tools)
+      } : {}
+    };
+  }
+};
+AiService = _ts_decorate6([
+  Injectable(),
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("design:paramtypes", [
+    typeof ProviderRegistry === "undefined" ? Object : ProviderRegistry,
+    typeof ToolRegistry === "undefined" ? Object : ToolRegistry
+  ])
+], AiService);
+
+// src/messages/message.types.ts
+function toMessages(input) {
+  if (typeof input === "string") {
+    return [
+      {
+        role: "user",
+        content: input
+      }
+    ];
+  }
+  return input;
+}
+__name(toMessages, "toMessages");
+
+// src/prompts/prompt.types.ts
+var PLACEHOLDER = /\{\{\s*([\w.]+)\s*\}\}/g;
+function interpolate(template, vars = {}) {
+  return template.replace(PLACEHOLDER, (_match, key) => {
+    if (!(key in vars)) {
+      throw new Error(`Missing variable "${key}" for prompt interpolation.`);
+    }
+    const value = vars[key];
+    return value == null ? "" : String(value);
+  });
+}
+__name(interpolate, "interpolate");
+
+// src/prompts/prompt-registry.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");
+var DEFAULT_VERSION = "__default__";
+var PromptRegistry = class {
+  static {
+    __name(this, "PromptRegistry");
+  }
+  /** name -> (version -> definition) */
+  prompts = /* @__PURE__ */ new Map();
+  /** name -> most recently registered version key */
+  latest = /* @__PURE__ */ new Map();
+  /** Registers a prompt. Throws on a duplicate (name, version). */
+  register(definition) {
+    const versions = this.prompts.get(definition.name) ?? /* @__PURE__ */ new Map();
+    const versionKey = definition.version ?? DEFAULT_VERSION;
+    if (versions.has(versionKey)) {
+      throw new Error(`Prompt "${definition.name}"${definition.version ? ` version "${definition.version}"` : ""} is already registered.`);
+    }
+    versions.set(versionKey, definition);
+    this.prompts.set(definition.name, versions);
+    this.latest.set(definition.name, versionKey);
+  }
+  /** Registers many prompts. */
+  registerAll(definitions) {
+    for (const definition of definitions) {
+      this.register(definition);
+    }
+  }
+  /** Returns a prompt definition (latest version when `version` omitted). */
+  get(name, version) {
+    const versions = this.prompts.get(name);
+    if (!versions) {
+      throw new Error(`Unknown prompt "${name}".`);
+    }
+    const versionKey = version ?? this.latest.get(name) ?? DEFAULT_VERSION;
+    const definition = versions.get(versionKey);
+    if (!definition) {
+      throw new Error(`Unknown version "${version}" for prompt "${name}".`);
+    }
+    return definition;
+  }
+  /** Renders a prompt to a string, interpolating `{{var}}` placeholders. */
+  render(name, vars = {}, options = {}) {
+    return interpolate(this.get(name, options.version).template, vars);
+  }
+  /** Whether a prompt (any version) is registered. */
+  has(name) {
+    return this.prompts.has(name);
+  }
+};
+PromptRegistry = _ts_decorate7([
+  Injectable()
+], PromptRegistry);
+
+// src/usage/pricing.ts
+var DEFAULT_PRICING = {
+  "gpt-4o": {
+    input: 2.5,
+    output: 10
+  },
+  "gpt-4o-mini": {
+    input: 0.15,
+    output: 0.6
+  },
+  "gpt-4.1": {
+    input: 2,
+    output: 8
+  },
+  "gpt-4.1-mini": {
+    input: 0.4,
+    output: 1.6
+  },
+  "o3-mini": {
+    input: 1.1,
+    output: 4.4
+  },
+  "text-embedding-3-small": {
+    input: 0.02,
+    output: 0
+  },
+  "text-embedding-3-large": {
+    input: 0.13,
+    output: 0
+  },
+  "claude-sonnet-4": {
+    input: 3,
+    output: 15
+  },
+  "claude-opus-4": {
+    input: 15,
+    output: 75
+  },
+  "claude-haiku-4": {
+    input: 0.8,
+    output: 4
+  },
+  "gemini-2.5-pro": {
+    input: 1.25,
+    output: 10
+  },
+  "gemini-2.5-flash": {
+    input: 0.3,
+    output: 2.5
+  }
+};
+function bareModelId(modelId) {
+  const sep = modelId.indexOf(":");
+  return sep === -1 ? modelId : modelId.slice(sep + 1);
+}
+__name(bareModelId, "bareModelId");
+function costOf(usage, modelId, pricing = DEFAULT_PRICING) {
+  const price = pricing[bareModelId(modelId)] ?? pricing[modelId];
+  if (!price) {
+    return 0;
+  }
+  const input = usage.inputTokens ?? 0;
+  const output = usage.outputTokens ?? 0;
+  return input / 1e6 * price.input + output / 1e6 * price.output;
+}
+__name(costOf, "costOf");
+
+// src/usage/usage-tracker.service.ts
+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_param4(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param4, "_ts_param");
+var GLOBAL = "__global__";
+function empty() {
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    cost: 0,
+    runs: 0
+  };
+}
+__name(empty, "empty");
+var UsageTracker = class {
+  static {
+    __name(this, "UsageTracker");
+  }
+  options;
+  events;
+  totalsByScope = /* @__PURE__ */ new Map();
+  constructor(options, events) {
+    this.options = options;
+    this.events = events;
+  }
+  /** Records a run's usage, returns the single-run record, emits `ai.usage`. */
+  record(entry) {
+    const usage = entry.usage ?? {};
+    const inputTokens = usage.inputTokens ?? 0;
+    const outputTokens = usage.outputTokens ?? 0;
+    const cost = costOf(usage, entry.model, this.options.pricing);
+    for (const scope of [
+      GLOBAL,
+      entry.conversationId
+    ].filter(Boolean)) {
+      const totals = this.totalsByScope.get(scope) ?? empty();
+      totals.inputTokens += inputTokens;
+      totals.outputTokens += outputTokens;
+      totals.cost += cost;
+      totals.runs += 1;
+      this.totalsByScope.set(scope, totals);
+    }
+    const record = {
+      conversationId: entry.conversationId,
+      agent: entry.agent,
+      model: entry.model,
+      inputTokens,
+      outputTokens,
+      cost,
+      runs: 1
+    };
+    this.events?.emit(AI_EVENTS.usage, record);
+    return record;
+  }
+  /** Totals for a conversation, or global totals when no id is given. */
+  totals(conversationId) {
+    return {
+      ...this.totalsByScope.get(conversationId ?? GLOBAL) ?? empty()
+    };
+  }
+  /** Clears totals for a conversation (or all when no id). */
+  reset(conversationId) {
+    if (conversationId) {
+      this.totalsByScope.delete(conversationId);
+    } else {
+      this.totalsByScope.clear();
+    }
+  }
+};
+UsageTracker = _ts_decorate8([
+  Injectable(),
+  _ts_param4(0, Inject(AI_MODULE_OPTIONS)),
+  _ts_param4(1, Optional()),
+  _ts_metadata7("design:type", Function),
+  _ts_metadata7("design:paramtypes", [
+    typeof AiModuleOptions === "undefined" ? Object : AiModuleOptions,
+    typeof AiEventEmitter === "undefined" ? Object : AiEventEmitter
+  ])
+], UsageTracker);
+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_param5(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param5, "_ts_param");
+var EmbeddingsService = class {
+  static {
+    __name(this, "EmbeddingsService");
+  }
+  providers;
+  cache;
+  constructor(providers, cache) {
+    this.providers = providers;
+    this.cache = cache;
+  }
+  /** Embeds a single value (cached when a cache is configured). */
+  async embed(value, options = {}) {
+    const model = this.providers.getEmbeddingModel(options.model);
+    const key = `emb:${model.modelId ?? ""}:${value}`;
+    if (this.cache) {
+      const hit = await this.cache.get(key);
+      if (hit !== void 0) {
+        return hit;
+      }
+    }
+    const result = await embed({
+      model,
+      value,
+      abortSignal: options.abortSignal,
+      maxRetries: options.maxRetries
+    });
+    if (this.cache) {
+      await this.cache.set(key, result);
+    }
+    return result;
+  }
+  /** Embeds many values (the SDK batches automatically). */
+  async embedMany(values, options = {}) {
+    return embedMany({
+      model: this.providers.getEmbeddingModel(options.model),
+      values,
+      abortSignal: options.abortSignal,
+      maxRetries: options.maxRetries
+    });
+  }
+};
+EmbeddingsService = _ts_decorate9([
+  Injectable(),
+  _ts_param5(1, Optional()),
+  _ts_param5(1, Inject(AI_CACHE)),
+  _ts_metadata8("design:type", Function),
+  _ts_metadata8("design:paramtypes", [
+    typeof ProviderRegistry === "undefined" ? Object : ProviderRegistry,
+    typeof AiCache === "undefined" ? Object : AiCache
+  ])
+], EmbeddingsService);
+
+// src/memory/semantic/semantic-memory.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_param6(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param6, "_ts_param");
+var SemanticMemory = class {
+  static {
+    __name(this, "SemanticMemory");
+  }
+  embeddings;
+  store;
+  ai;
+  constructor(embeddings, store, ai) {
+    this.embeddings = embeddings;
+    this.store = store;
+    this.ai = ai;
+  }
+  /** Embeds and stores a snippet under a conversation. */
+  async remember(conversationId, text, options = {}) {
+    const { embedding } = await this.embeddings.embed(text, {
+      model: options.model
+    });
+    await this.store.upsert([
+      {
+        id: `mem:${conversationId}:${hash(text)}`,
+        content: text,
+        embedding,
+        metadata: {
+          conversationId,
+          kind: "memory",
+          ...options.metadata
+        }
+      }
+    ]);
+  }
+  /** Returns the most relevant stored snippets for a query. */
+  async recall(conversationId, query, options = {}) {
+    const { embedding } = await this.embeddings.embed(query, {
+      model: options.model
+    });
+    return this.store.query(embedding, {
+      topK: options.topK ?? 4,
+      filter: {
+        conversationId,
+        kind: "memory"
+      }
+    });
+  }
+  /**
+  * Summarizes messages with the LLM (requires `AiService`), then stores the
+  * summary as a memory snippet. Returns the stored text.
+  */
+  async rememberConversation(conversationId, input, options = {}) {
+    const text = options.summarize ? await this.summarize(input, options.model) : messagesToText(input);
+    await this.remember(conversationId, text, {
+      model: options.model
+    });
+    return text;
+  }
+  /** Summarizes messages into a compact string via the LLM. */
+  async summarize(input, model) {
+    if (!this.ai) {
+      throw new Error("SemanticMemory.summarize requires AiService.");
+    }
+    const { text } = await this.ai.generateText({
+      model,
+      prompt: `Summarize the following conversation concisely:
+
+${messagesToText(input)}`
+    });
+    return text;
+  }
+};
+SemanticMemory = _ts_decorate10([
+  Injectable(),
+  _ts_param6(1, Inject(VECTOR_STORE)),
+  _ts_param6(2, Optional()),
+  _ts_metadata9("design:type", Function),
+  _ts_metadata9("design:paramtypes", [
+    typeof EmbeddingsService === "undefined" ? Object : EmbeddingsService,
+    typeof VectorStore === "undefined" ? Object : VectorStore,
+    typeof AiService === "undefined" ? Object : AiService
+  ])
+], SemanticMemory);
+function messagesToText(input) {
+  return toMessages(input).map((m) => {
+    const content = m.content;
+    if (typeof content === "string") {
+      return `${m.role}: ${content}`;
+    }
+    if (Array.isArray(content)) {
+      return `${m.role}: ${content.map((p) => p && typeof p.text === "string" ? p.text : "").join(" ")}`;
+    }
+    return "";
+  }).join("\n");
+}
+__name(messagesToText, "messagesToText");
+function hash(text) {
+  let h = 5381;
+  for (let i = 0; i < text.length; i++) {
+    h = h * 33 ^ text.charCodeAt(i);
+  }
+  return (h >>> 0).toString(36);
+}
+__name(hash, "hash");
+
+// src/agent/agent-executor.service.ts
+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_param7(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param7, "_ts_param");
+var AgentExecutorService = class {
+  static {
+    __name(this, "AgentExecutorService");
+  }
+  providers;
+  toolRegistry;
+  store;
+  options;
+  events;
+  guardrails;
+  prompts;
+  usageTracker;
+  semanticMemory;
+  constructor(providers, toolRegistry, store, options, events, guardrails, prompts, usageTracker, semanticMemory) {
+    this.providers = providers;
+    this.toolRegistry = toolRegistry;
+    this.store = store;
+    this.options = options;
+    this.events = events;
+    this.guardrails = guardrails;
+    this.prompts = prompts;
+    this.usageTracker = usageTracker;
+    this.semanticMemory = semanticMemory;
+  }
+  /** Runs an agent to completion and returns its result. */
+  async run(agent, input, opts = {}) {
+    const meta = this.readMetadata(agent);
+    const agentName = agent.constructor?.name ?? "AiAgent";
+    const model = this.providers.getLanguageModel(opts.model ?? meta.model);
+    const system = await this.resolveSystemWithRecall(opts, meta, input);
+    const schema = opts.schema ?? meta.output;
+    const maxSteps = this.resolveMaxSteps(opts, meta);
+    const newMessages = toMessages(input);
+    const history = await this.loadHistory(opts.conversationId);
+    const ctx = {
+      agent: agentName,
+      messages: [
+        ...history,
+        ...newMessages
+      ],
+      options: opts
+    };
+    this.events?.emit(AI_EVENTS.agentRunStart, {
+      agent: agentName,
+      input,
+      options: opts
+    });
+    try {
+      await this.guardrails?.runBeforeRun(ctx);
+      const result = schema ? await this.runObject(model, system, ctx.messages, schema, opts, newMessages) : await this.runText(model, system, ctx.messages, meta, maxSteps, opts, newMessages);
+      this.usageTracker?.record({
+        model: model.modelId ?? "unknown",
+        usage: result.usage,
+        conversationId: opts.conversationId,
+        agent: agentName
+      });
+      await this.guardrails?.runAfterRun(ctx, result);
+      this.events?.emit(AI_EVENTS.agentRunFinish, {
+        agent: agentName,
+        result
+      });
+      return result;
+    } catch (error) {
+      this.events?.emit(AI_EVENTS.agentRunError, {
+        agent: agentName,
+        error
+      });
+      throw error;
+    }
+  }
+  async runObject(model, system, messages, schema, opts, newMessages) {
+    const result = await generateObject({
+      model,
+      system,
+      messages,
+      schema,
+      abortSignal: opts.abortSignal,
+      temperature: opts.temperature,
+      maxRetries: opts.maxRetries ?? this.options.maxRetries,
+      experimental_telemetry: this.telemetry()
+    });
+    await this.persist(opts.conversationId, newMessages, [
+      {
+        role: "assistant",
+        content: JSON.stringify(result.object)
+      }
+    ]);
+    return {
+      text: "",
+      object: result.object,
+      usage: result.usage,
+      finishReason: result.finishReason,
+      messages: []
+    };
+  }
+  async runText(model, system, messages, meta, maxSteps, opts, newMessages) {
+    const result = await generateText({
+      model,
+      system,
+      messages,
+      tools: this.toolRegistry.buildToolSet(meta.tools),
+      stopWhen: stepCountIs(maxSteps),
+      abortSignal: opts.abortSignal,
+      temperature: opts.temperature,
+      maxRetries: opts.maxRetries ?? this.options.maxRetries,
+      experimental_telemetry: this.telemetry()
+    });
+    await this.persist(opts.conversationId, newMessages, result.response.messages);
+    return {
+      text: result.text,
+      steps: result.steps,
+      toolCalls: result.toolCalls,
+      usage: result.totalUsage,
+      finishReason: result.finishReason,
+      messages: result.response.messages
+    };
+  }
+  /**
+  * Streams an agent's response. Returns the raw Vercel stream result so
+  * controllers can pipe it to an HTTP response or iterate `textStream`.
+  * Conversation persistence happens on stream finish.
+  */
+  stream(agent, input, opts = {}) {
+    const meta = this.readMetadata(agent);
+    const agentName = agent.constructor?.name ?? "AiAgent";
+    const model = this.providers.getLanguageModel(opts.model ?? meta.model);
+    const system = this.resolveSystem(opts, meta);
+    const schema = opts.schema ?? meta.output;
+    const maxSteps = this.resolveMaxSteps(opts, meta);
+    const newMessages = toMessages(input);
+    this.events?.emit(AI_EVENTS.agentRunStart, {
+      agent: agentName,
+      input,
+      options: opts
+    });
+    if (schema) {
+      return streamObject({
+        model,
+        system,
+        messages: newMessages,
+        schema,
+        abortSignal: opts.abortSignal,
+        temperature: opts.temperature,
+        experimental_telemetry: this.telemetry(),
+        onFinish: /* @__PURE__ */ __name(async ({ object }) => {
+          if (object !== void 0) {
+            await this.persist(opts.conversationId, newMessages, [
+              {
+                role: "assistant",
+                content: JSON.stringify(object)
+              }
+            ]);
+          }
+          this.events?.emit(AI_EVENTS.streamFinish, {
+            agent: agentName
+          });
+        }, "onFinish")
+      });
+    }
+    return streamText({
+      model,
+      system,
+      messages: newMessages,
+      tools: this.toolRegistry.buildToolSet(meta.tools),
+      stopWhen: stepCountIs(maxSteps),
+      abortSignal: opts.abortSignal,
+      temperature: opts.temperature,
+      maxRetries: opts.maxRetries ?? this.options.maxRetries,
+      experimental_telemetry: this.telemetry(),
+      onFinish: /* @__PURE__ */ __name(async ({ response }) => {
+        await this.persist(opts.conversationId, newMessages, response.messages);
+        this.events?.emit(AI_EVENTS.streamFinish, {
+          agent: agentName
+        });
+      }, "onFinish")
+    });
+  }
+  /** Resolves the system prompt and prepends recalled memory when requested. */
+  async resolveSystemWithRecall(opts, meta, input) {
+    let system = this.resolveSystem(opts, meta);
+    if (opts.recall && opts.conversationId && this.semanticMemory) {
+      const query = opts.recall.query ?? (typeof input === "string" ? input : "");
+      if (query) {
+        const snippets = await this.semanticMemory.recall(opts.conversationId, query, {
+          topK: opts.recall.topK
+        });
+        if (snippets.length > 0) {
+          const context = snippets.map((s) => s.content).join("\n");
+          system = [
+            system,
+            `Relevant context from memory:
+${context}`
+          ].filter(Boolean).join("\n\n");
+        }
+      }
+    }
+    return system;
+  }
+  resolveSystem(opts, meta) {
+    if (opts.systemPrompt) {
+      if (!this.prompts) {
+        throw new Error("systemPrompt requires the PromptRegistry (AiModule must be imported).");
+      }
+      return this.prompts.render(opts.systemPrompt.name, opts.systemPrompt.vars, {
+        version: opts.systemPrompt.version
+      });
+    }
+    return opts.system ?? meta.system;
+  }
+  telemetry() {
+    const t = this.options.telemetry;
+    if (!t?.isEnabled) {
+      return void 0;
+    }
+    return {
+      isEnabled: true,
+      functionId: t.functionId
+    };
+  }
+  readMetadata(agent) {
+    const ctor = agent.constructor;
+    return Reflect.getMetadata(AGENT_METADATA, ctor) ?? {};
+  }
+  resolveMaxSteps(opts, meta) {
+    return opts.maxSteps ?? meta.maxSteps ?? this.options.defaultMaxSteps ?? DEFAULT_MAX_STEPS;
+  }
+  async loadHistory(conversationId) {
+    if (!conversationId) {
+      return [];
+    }
+    return this.store.load(conversationId);
+  }
+  async persist(conversationId, userMessages, responseMessages) {
+    if (!conversationId) {
+      return;
+    }
+    await this.store.append(conversationId, [
+      ...userMessages,
+      ...responseMessages
+    ]);
+  }
+};
+AgentExecutorService = _ts_decorate11([
+  Injectable(),
+  _ts_param7(2, Inject(CONVERSATION_STORE)),
+  _ts_param7(3, Inject(AI_MODULE_OPTIONS)),
+  _ts_param7(4, Optional()),
+  _ts_param7(5, Optional()),
+  _ts_param7(6, Optional()),
+  _ts_param7(7, Optional()),
+  _ts_param7(8, Optional()),
+  _ts_metadata10("design:type", Function),
+  _ts_metadata10("design:paramtypes", [
+    typeof ProviderRegistry === "undefined" ? Object : ProviderRegistry,
+    typeof ToolRegistry === "undefined" ? Object : ToolRegistry,
+    typeof ConversationStore === "undefined" ? Object : ConversationStore,
+    typeof AiModuleOptions === "undefined" ? Object : AiModuleOptions,
+    typeof AiEventEmitter === "undefined" ? Object : AiEventEmitter,
+    typeof GuardrailRegistry === "undefined" ? Object : GuardrailRegistry,
+    typeof PromptRegistry === "undefined" ? Object : PromptRegistry,
+    typeof UsageTracker === "undefined" ? Object : UsageTracker,
+    typeof SemanticMemory === "undefined" ? Object : SemanticMemory
+  ])
+], AgentExecutorService);
+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 InMemoryConversationStore = class {
+  static {
+    __name(this, "InMemoryConversationStore");
+  }
+  conversations = /* @__PURE__ */ new Map();
+  async load(conversationId) {
+    return [
+      ...this.conversations.get(conversationId) ?? []
+    ];
+  }
+  async append(conversationId, messages) {
+    const existing = this.conversations.get(conversationId) ?? [];
+    this.conversations.set(conversationId, [
+      ...existing,
+      ...messages
+    ]);
+  }
+  async clear(conversationId) {
+    this.conversations.delete(conversationId);
+  }
+};
+InMemoryConversationStore = _ts_decorate12([
+  Injectable()
+], InMemoryConversationStore);
+function _ts_decorate13(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_decorate13, "_ts_decorate");
+function _ts_metadata11(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata11, "_ts_metadata");
+var ImageService = class {
+  static {
+    __name(this, "ImageService");
+  }
+  providers;
+  constructor(providers) {
+    this.providers = providers;
+  }
+  generate(prompt, options = {}) {
+    const { model, ...rest } = options;
+    return generateImage({
+      model: this.providers.getImageModel(model),
+      prompt,
+      ...rest
+    });
+  }
+};
+ImageService = _ts_decorate13([
+  Injectable(),
+  _ts_metadata11("design:type", Function),
+  _ts_metadata11("design:paramtypes", [
+    typeof ProviderRegistry === "undefined" ? Object : ProviderRegistry
+  ])
+], ImageService);
+function _ts_decorate14(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_decorate14, "_ts_decorate");
+function _ts_metadata12(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata12, "_ts_metadata");
+var SpeechService = class {
+  static {
+    __name(this, "SpeechService");
+  }
+  providers;
+  constructor(providers) {
+    this.providers = providers;
+  }
+  generate(text, options = {}) {
+    const { model, ...rest } = options;
+    return experimental_generateSpeech({
+      model: this.providers.getSpeechModel(model),
+      text,
+      ...rest
+    });
+  }
+};
+SpeechService = _ts_decorate14([
+  Injectable(),
+  _ts_metadata12("design:type", Function),
+  _ts_metadata12("design:paramtypes", [
+    typeof ProviderRegistry === "undefined" ? Object : ProviderRegistry
+  ])
+], SpeechService);
+function _ts_decorate15(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_decorate15, "_ts_decorate");
+function _ts_metadata13(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata13, "_ts_metadata");
+var TranscriptionService = class {
+  static {
+    __name(this, "TranscriptionService");
+  }
+  providers;
+  constructor(providers) {
+    this.providers = providers;
+  }
+  transcribe(audio, options = {}) {
+    const { model, ...rest } = options;
+    return experimental_transcribe({
+      model: this.providers.getTranscriptionModel(model),
+      audio,
+      ...rest
+    });
+  }
+};
+TranscriptionService = _ts_decorate15([
+  Injectable(),
+  _ts_metadata13("design:type", Function),
+  _ts_metadata13("design:paramtypes", [
+    typeof ProviderRegistry === "undefined" ? Object : ProviderRegistry
+  ])
+], TranscriptionService);
+function _ts_decorate16(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_decorate16, "_ts_decorate");
+function _ts_metadata14(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata14, "_ts_metadata");
+function _ts_param8(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param8, "_ts_param");
+var RagService = class {
+  static {
+    __name(this, "RagService");
+  }
+  embeddings;
+  store;
+  defaultReranker;
+  constructor(embeddings, store, defaultReranker) {
+    this.embeddings = embeddings;
+    this.store = store;
+    this.defaultReranker = defaultReranker;
+  }
+  /** Chunks, embeds, and upserts items into the vector store. */
+  async ingest(items, options = {}) {
+    const chunkSize = options.chunkSize ?? 1e3;
+    const overlap2 = options.chunkOverlap ?? 100;
+    const chunks = [];
+    items.forEach((item, index) => {
+      const baseId = item.id ?? `doc-${index}`;
+      splitText(item.content, chunkSize, overlap2).forEach((text, chunkIndex) => {
+        chunks.push({
+          id: `${baseId}#${chunkIndex}`,
+          content: text,
+          metadata: item.metadata
+        });
+      });
+    });
+    if (chunks.length === 0) {
+      return;
+    }
+    const { embeddings } = await this.embeddings.embedMany(chunks.map((c) => c.content), {
+      model: options.model
+    });
+    const documents = chunks.map((chunk, i) => ({
+      ...chunk,
+      embedding: embeddings[i]
+    }));
+    await this.store.upsert(documents);
+  }
+  /** Embeds `query` and returns the most similar stored chunks. */
+  async retrieve(query, options = {}) {
+    const { embedding } = await this.embeddings.embed(query, {
+      model: options.model
+    });
+    const topK = options.topK ?? 4;
+    const reranker = options.rerank === true ? this.defaultReranker : options.rerank || void 0;
+    const fetchK = reranker ? options.fetchK ?? topK * 4 : topK;
+    const results = await this.store.query(embedding, {
+      topK: fetchK,
+      filter: options.filter
+    });
+    if (reranker) {
+      return reranker.rerank(query, results, topK);
+    }
+    return results.slice(0, topK);
+  }
+};
+RagService = _ts_decorate16([
+  Injectable(),
+  _ts_param8(1, Inject(VECTOR_STORE)),
+  _ts_param8(2, Optional()),
+  _ts_param8(2, Inject(RERANKER)),
+  _ts_metadata14("design:type", Function),
+  _ts_metadata14("design:paramtypes", [
+    typeof EmbeddingsService === "undefined" ? Object : EmbeddingsService,
+    typeof VectorStore === "undefined" ? Object : VectorStore,
+    typeof Reranker === "undefined" ? Object : Reranker
+  ])
+], RagService);
+function splitText(text, chunkSize, overlap2) {
+  if (chunkSize <= 0 || text.length <= chunkSize) {
+    return text.length > 0 ? [
+      text
+    ] : [];
+  }
+  const step = Math.max(1, chunkSize - overlap2);
+  const chunks = [];
+  for (let start = 0; start < text.length; start += step) {
+    chunks.push(text.slice(start, start + chunkSize));
+    if (start + chunkSize >= text.length) {
+      break;
+    }
+  }
+  return chunks;
+}
+__name(splitText, "splitText");
+function _ts_decorate17(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_decorate17, "_ts_decorate");
+var InMemoryVectorStore = class {
+  static {
+    __name(this, "InMemoryVectorStore");
+  }
+  documents = /* @__PURE__ */ new Map();
+  async upsert(documents) {
+    for (const doc of documents) {
+      if (!doc.embedding) {
+        throw new Error(`Document "${doc.id}" has no embedding. InMemoryVectorStore requires precomputed embeddings (use RagService.ingest).`);
+      }
+      this.documents.set(doc.id, doc);
+    }
+  }
+  async query(embedding, options = {}) {
+    const topK = options.topK ?? 4;
+    const filter = options.filter;
+    const scored = [];
+    for (const doc of this.documents.values()) {
+      if (filter && !this.matchesFilter(doc, filter)) {
+        continue;
+      }
+      scored.push({
+        id: doc.id,
+        content: doc.content,
+        score: cosineSimilarity(embedding, doc.embedding),
+        metadata: doc.metadata
+      });
+    }
+    return scored.sort((a, b) => b.score - a.score).slice(0, topK);
+  }
+  async delete(ids) {
+    for (const id of ids) {
+      this.documents.delete(id);
+    }
+  }
+  async clear() {
+    this.documents.clear();
+  }
+  matchesFilter(doc, filter) {
+    return Object.entries(filter).every(([key, value]) => doc.metadata?.[key] === value);
+  }
+};
+InMemoryVectorStore = _ts_decorate17([
+  Injectable()
+], InMemoryVectorStore);
+function _ts_decorate18(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_decorate18, "_ts_decorate");
+var McpService = class {
+  static {
+    __name(this, "McpService");
+  }
+  clients = /* @__PURE__ */ new Map();
+  toolSets = /* @__PURE__ */ new Map();
+  /**
+  * Registers an MCP client under `name`, lists its tools, and builds a
+  * matching AI SDK tool set. Returns the tool set.
+  */
+  async connect(name, client) {
+    const { tools } = await client.listTools();
+    const set = {};
+    for (const info of tools) {
+      set[info.name] = dynamicTool({
+        description: info.description ?? info.name,
+        inputSchema: jsonSchema(info.inputSchema),
+        execute: /* @__PURE__ */ __name(async (args) => {
+          const result = await client.callTool({
+            name: info.name,
+            arguments: args ?? {}
+          });
+          return extractText(result);
+        }, "execute")
+      });
+    }
+    this.clients.set(name, client);
+    this.toolSets.set(name, set);
+    return set;
+  }
+  /** Returns the tool set for a connected server (empty if unknown). */
+  getToolSet(name) {
+    return this.toolSets.get(name) ?? {};
+  }
+  /** Returns tool sets for all connected servers, merged. */
+  getAllTools() {
+    return Object.assign({}, ...this.toolSets.values());
+  }
+  async onModuleDestroy() {
+    await this.closeAll();
+  }
+  /** Closes every connected client. */
+  async closeAll() {
+    for (const client of this.clients.values()) {
+      await client.close?.();
+    }
+    this.clients.clear();
+    this.toolSets.clear();
+  }
+};
+McpService = _ts_decorate18([
+  Injectable()
+], McpService);
+function extractText(result) {
+  if (!result.content) {
+    return "";
+  }
+  return result.content.filter((part) => part.type === "text" && typeof part.text === "string").map((part) => part.text).join("\n");
+}
+__name(extractText, "extractText");
+function Guardrail() {
+  return (target) => {
+    Reflect.defineMetadata(GUARDRAIL_METADATA, true, target);
+    Injectable()(target);
+  };
+}
+__name(Guardrail, "Guardrail");
+
+// src/usage/budget.guardrail.ts
+function _ts_decorate19(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_decorate19, "_ts_decorate");
+function _ts_metadata15(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata15, "_ts_metadata");
+function _ts_param9(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param9, "_ts_param");
+var BudgetExceededError = class extends Error {
+  static {
+    __name(this, "BudgetExceededError");
+  }
+  conversationId;
+  spent;
+  limit;
+  constructor(conversationId, spent, limit) {
+    super(`Budget exceeded${conversationId ? ` for "${conversationId}"` : ""}: $${spent.toFixed(4)} >= $${limit.toFixed(4)}.`), this.conversationId = conversationId, this.spent = spent, this.limit = limit;
+    this.name = "BudgetExceededError";
+  }
+};
+var BudgetGuard = class {
+  static {
+    __name(this, "BudgetGuard");
+  }
+  usage;
+  options;
+  constructor(usage, options) {
+    this.usage = usage;
+    this.options = options;
+  }
+  beforeRun(ctx) {
+    const limit = this.options.maxCostPerConversation;
+    if (limit == null) {
+      return;
+    }
+    const { cost } = this.usage.totals(ctx.options.conversationId);
+    if (cost >= limit) {
+      throw new BudgetExceededError(ctx.options.conversationId, cost, limit);
+    }
+  }
+};
+BudgetGuard = _ts_decorate19([
+  Guardrail(),
+  Injectable(),
+  _ts_param9(1, Inject(AI_MODULE_OPTIONS)),
+  _ts_metadata15("design:type", Function),
+  _ts_metadata15("design:paramtypes", [
+    typeof UsageTracker === "undefined" ? Object : UsageTracker,
+    typeof AiModuleOptions === "undefined" ? Object : AiModuleOptions
+  ])
+], BudgetGuard);
+
+// src/ratelimit/rate-limiter.interface.ts
+var RateLimitedError = class extends Error {
+  static {
+    __name(this, "RateLimitedError");
+  }
+  key;
+  constructor(key) {
+    super(`Rate limit exceeded for "${key}".`), this.key = key;
+    this.name = "RateLimitedError";
+  }
+};
+
+// src/ratelimit/rate-limit.guardrail.ts
+function _ts_decorate20(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_decorate20, "_ts_decorate");
+function _ts_metadata16(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata16, "_ts_metadata");
+function _ts_param10(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param10, "_ts_param");
+var RateLimitGuardrail = class {
+  static {
+    __name(this, "RateLimitGuardrail");
+  }
+  limiter;
+  constructor(limiter) {
+    this.limiter = limiter;
+  }
+  async beforeRun(ctx) {
+    const key = ctx.options.conversationId ?? "global";
+    const allowed = await this.limiter.consume(key);
+    if (!allowed) {
+      throw new RateLimitedError(key);
+    }
+  }
+};
+RateLimitGuardrail = _ts_decorate20([
+  Guardrail(),
+  Injectable(),
+  _ts_param10(0, Inject(RATE_LIMITER)),
+  _ts_metadata16("design:type", Function),
+  _ts_metadata16("design:paramtypes", [
+    typeof RateLimiter === "undefined" ? Object : RateLimiter
+  ])
+], RateLimitGuardrail);
+function _ts_decorate21(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_decorate21, "_ts_decorate");
+function _ts_metadata17(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata17, "_ts_metadata");
+function _ts_param11(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param11, "_ts_param");
+var HeuristicReranker = class {
+  static {
+    __name(this, "HeuristicReranker");
+  }
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async rerank(query, results, topN) {
+    const weight = this.options.overlapWeight ?? 0.5;
+    const terms = tokenize(query);
+    return results.map((result) => ({
+      result,
+      score: result.score + weight * overlap(terms, result.content)
+    })).sort((a, b) => b.score - a.score).slice(0, topN).map(({ result, score }) => ({
+      ...result,
+      score
+    }));
+  }
+};
+HeuristicReranker = _ts_decorate21([
+  Injectable(),
+  _ts_param11(0, Optional()),
+  _ts_metadata17("design:type", Function),
+  _ts_metadata17("design:paramtypes", [
+    typeof HeuristicRerankerOptions === "undefined" ? Object : HeuristicRerankerOptions
+  ])
+], HeuristicReranker);
+function tokenize(text) {
+  return new Set(text.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 2));
+}
+__name(tokenize, "tokenize");
+function overlap(terms, content) {
+  if (terms.size === 0) {
+    return 0;
+  }
+  const contentTerms = tokenize(content);
+  let hits = 0;
+  for (const term of terms) {
+    if (contentTerms.has(term)) {
+      hits++;
+    }
+  }
+  return hits / terms.size;
+}
+__name(overlap, "overlap");
+function _ts_decorate22(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_decorate22, "_ts_decorate");
+var EvalRunner = class {
+  static {
+    __name(this, "EvalRunner");
+  }
+  async run(agent, cases, options = {}) {
+    const judge = options.judge ?? defaultJudge(options.passThreshold ?? 1);
+    const results = [];
+    for (const evalCase of cases) {
+      const { text } = await agent.run(evalCase.input);
+      const score = await judge({
+        case: evalCase,
+        output: text
+      });
+      results.push({
+        name: evalCase.name ?? evalCase.input,
+        input: evalCase.input,
+        output: text,
+        ...score
+      });
+    }
+    const averageScore = results.length ? results.reduce((sum, r) => sum + r.score, 0) / results.length : 0;
+    const passRate = results.length ? results.filter((r) => r.passed).length / results.length : 0;
+    return {
+      results,
+      averageScore,
+      passRate
+    };
+  }
+};
+EvalRunner = _ts_decorate22([
+  Injectable()
+], EvalRunner);
+function defaultJudge(threshold) {
+  return ({ case: evalCase, output }) => {
+    if (evalCase.expected == null) {
+      return {
+        score: 0,
+        passed: false,
+        reasoning: "no expected value or judge"
+      };
+    }
+    const score = output.includes(evalCase.expected) ? 1 : 0;
+    return {
+      score,
+      passed: score >= threshold
+    };
+  };
+}
+__name(defaultJudge, "defaultJudge");
+
+// src/ai.module.ts
+function _ts_decorate23(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_decorate23, "_ts_decorate");
+var AI_INITIALIZER = /* @__PURE__ */ Symbol("AI_INITIALIZER");
+var AiModule = class _AiModule {
+  static {
+    __name(this, "AiModule");
+  }
+  /** Configure the module with static options. */
+  static forRoot(options = {}) {
+    return _AiModule.build({
+      provide: AI_MODULE_OPTIONS,
+      useValue: options
+    }, options);
+  }
+  /** Configure the module asynchronously (e.g. from `ConfigService`). */
+  static forRootAsync(options) {
+    return _AiModule.build({
+      provide: AI_MODULE_OPTIONS,
+      useFactory: options.useFactory,
+      inject: options.inject ?? []
+    }, options, options.imports);
+  }
+  /**
+  * Convenience registration of agents / tools / guardrails so they don't have
+  * to be added to a consuming module's own `providers` array, plus feature
+  * prompts. Discovery still finds providers globally regardless of where they
+  * are registered.
+  */
+  static forFeature(feature = {}) {
+    const providers = [
+      ...feature.agents ?? [],
+      ...feature.tools ?? [],
+      ...feature.guardrails ?? []
+    ];
+    if (feature.prompts?.length) {
+      providers.push({
+        provide: /* @__PURE__ */ Symbol("AI_FEATURE_PROMPTS"),
+        useFactory: /* @__PURE__ */ __name((registry) => {
+          registry.registerAll(feature.prompts);
+          return true;
+        }, "useFactory"),
+        inject: [
+          PromptRegistry
+        ]
+      });
+    }
+    return {
+      module: _AiModule,
+      providers,
+      exports: providers
+    };
+  }
+  static build(optionsProvider, options, extraImports = []) {
+    return {
+      module: _AiModule,
+      imports: [
+        DiscoveryModule,
+        ...extraImports ?? []
+      ],
+      providers: [
+        optionsProvider,
+        _AiModule.storeProvider(options.conversationStore),
+        _AiModule.vectorStoreProvider(options.vectorStore),
+        _AiModule.eventEmitterProvider(),
+        ..._AiModule.tokenProvider(AI_CACHE, options.cache),
+        ..._AiModule.tokenProvider(APPROVAL_GATE, options.approvalGate),
+        ..._AiModule.tokenProvider(RATE_LIMITER, options.rateLimiter),
+        ..._AiModule.guardrailClasses(options.guardrails),
+        ...options.maxCostPerConversation != null ? [
+          BudgetGuard
+        ] : [],
+        ...options.rateLimiter ? [
+          RateLimitGuardrail
+        ] : [],
+        ..._AiModule.coreProviders(),
+        _AiModule.initializerProvider()
+      ],
+      exports: _AiModule.exportedTokens()
+    };
+  }
+  static coreProviders() {
+    return [
+      ProviderRegistry,
+      ToolRegistry,
+      AgentExecutorService,
+      AgentRegistry,
+      AiService,
+      EmbeddingsService,
+      ImageService,
+      SpeechService,
+      TranscriptionService,
+      RagService,
+      PromptRegistry,
+      AiEventEmitter,
+      GuardrailRegistry,
+      McpService,
+      UsageTracker,
+      SemanticMemory,
+      EvalRunner,
+      {
+        provide: RERANKER,
+        useFactory: /* @__PURE__ */ __name(() => new HeuristicReranker(), "useFactory")
+      }
+    ];
+  }
+  /**
+  * Registers an optional provider (class / factory / value / useClass shape)
+  * under `token`, or nothing when not configured.
+  */
+  static tokenProvider(token, config) {
+    if (!config) {
+      return [];
+    }
+    if (typeof config === "function") {
+      return [
+        {
+          provide: token,
+          useClass: config
+        }
+      ];
+    }
+    return [
+      {
+        provide: token,
+        ...config
+      }
+    ];
+  }
+  static exportedTokens() {
+    return [
+      ProviderRegistry,
+      ToolRegistry,
+      AgentExecutorService,
+      AgentRegistry,
+      AiService,
+      EmbeddingsService,
+      ImageService,
+      SpeechService,
+      TranscriptionService,
+      RagService,
+      PromptRegistry,
+      AiEventEmitter,
+      GuardrailRegistry,
+      McpService,
+      UsageTracker,
+      SemanticMemory,
+      EvalRunner,
+      RERANKER,
+      CONVERSATION_STORE,
+      VECTOR_STORE,
+      AI_MODULE_OPTIONS
+    ];
+  }
+  static guardrailClasses(guardrails) {
+    return guardrails ?? [];
+  }
+  /** Seeds prompts (and future startup wiring) once dependencies exist. */
+  static initializerProvider() {
+    return {
+      provide: AI_INITIALIZER,
+      useFactory: /* @__PURE__ */ __name((registry, opts) => {
+        if (opts.prompts?.length) {
+          registry.registerAll(opts.prompts);
+        }
+        return true;
+      }, "useFactory"),
+      inject: [
+        PromptRegistry,
+        AI_MODULE_OPTIONS
+      ]
+    };
+  }
+  /**
+  * Optionally resolves `EventEmitter2` from `@nestjs/event-emitter` if the
+  * package is installed and its module is imported; otherwise `undefined`.
+  */
+  static eventEmitterProvider() {
+    return {
+      provide: EVENT_EMITTER,
+      useFactory: /* @__PURE__ */ __name(async (moduleRef) => {
+        try {
+          const mod = await import('@nestjs/event-emitter');
+          return moduleRef.get(mod.EventEmitter2, {
+            strict: false
+          });
+        } catch {
+          return void 0;
+        }
+      }, "useFactory"),
+      inject: [
+        ModuleRef
+      ]
+    };
+  }
+  static storeProvider(store) {
+    if (!store) {
+      return {
+        provide: CONVERSATION_STORE,
+        useClass: InMemoryConversationStore
+      };
+    }
+    if (typeof store === "function") {
+      return {
+        provide: CONVERSATION_STORE,
+        useClass: store
+      };
+    }
+    return {
+      provide: CONVERSATION_STORE,
+      ...store
+    };
+  }
+  static vectorStoreProvider(store) {
+    if (!store) {
+      return {
+        provide: VECTOR_STORE,
+        useClass: InMemoryVectorStore
+      };
+    }
+    if (typeof store === "function") {
+      return {
+        provide: VECTOR_STORE,
+        useClass: store
+      };
+    }
+    return {
+      provide: VECTOR_STORE,
+      ...store
+    };
+  }
+};
+AiModule = _ts_decorate23([
+  Global(),
+  Module({})
+], AiModule);
+
+// src/testing/testing.module.ts
+async function createTestingAiModule(options = {}) {
+  const model = options.model ?? createMockModel("mock response");
+  const embedding = options.embedding ?? createEmbeddingMock(() => [
+    0
+  ]);
+  const moduleRef = await Test.createTestingModule({
+    imports: [
+      AiModule.forRoot(options.aiOptions ?? {
+        providers: {
+          openai: {
+            apiKey: "test"
+          }
+        }
+      }),
+      ...options.imports ?? []
+    ],
+    providers: options.providers ?? []
+  }).overrideProvider(ProviderRegistry).useValue({
+    getLanguageModel: /* @__PURE__ */ __name(() => model, "getLanguageModel"),
+    getEmbeddingModel: /* @__PURE__ */ __name(() => embedding, "getEmbeddingModel"),
+    getImageModel: /* @__PURE__ */ __name(() => {
+      throw new Error("No image model mock configured.");
+    }, "getImageModel"),
+    getSpeechModel: /* @__PURE__ */ __name(() => {
+      throw new Error("No speech model mock configured.");
+    }, "getSpeechModel"),
+    getTranscriptionModel: /* @__PURE__ */ __name(() => {
+      throw new Error("No transcription model mock configured.");
+    }, "getTranscriptionModel"),
+    getRerankingModel: /* @__PURE__ */ __name(() => {
+      throw new Error("No reranking model mock configured.");
+    }, "getRerankingModel")
+  }).compile();
+  await moduleRef.init();
+  return moduleRef;
+}
+__name(createTestingAiModule, "createTestingAiModule");
+
+export { createEmbeddingMock, createMockModel, createTestingAiModule };
+//# sourceMappingURL=testing.js.map
+//# sourceMappingURL=testing.js.map