@mgvdev/nestjs-ai 0.1.0

package/dist/index.cjs

@@ -0,0 +1,3209 @@
+'use strict';
+
+require('reflect-metadata');
+var common = require('@nestjs/common');
+var core = require('@nestjs/core');
+var ai = require('ai');
+var zod = require('zod');
+var rxjs = require('rxjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// 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 AGENT_QUEUE = /* @__PURE__ */ Symbol("AGENT_QUEUE");
+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");
+exports.ProviderRegistry = class ProviderRegistry {
+  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 ai.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;
+    }
+  }
+};
+exports.ProviderRegistry = _ts_decorate([
+  common.Injectable(),
+  _ts_param(0, common.Inject(AI_MODULE_OPTIONS)),
+  _ts_param(1, common.Optional()),
+  _ts_param(1, common.Inject(AI_CACHE)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof AiModuleOptions === "undefined" ? Object : AiModuleOptions,
+    typeof AiCache === "undefined" ? Object : AiCache
+  ])
+], exports.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");
+exports.AiEventEmitter = class AiEventEmitter {
+  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;
+  }
+};
+exports.AiEventEmitter = _ts_decorate2([
+  common.Injectable(),
+  _ts_param2(0, common.Optional()),
+  _ts_param2(0, common.Inject(EVENT_EMITTER)),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    Object
+  ])
+], exports.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");
+exports.GuardrailRegistry = class GuardrailRegistry {
+  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(tool4, args) {
+    for (const guardrail of this.guardrails) {
+      await guardrail.onToolCall?.(tool4, args);
+    }
+  }
+};
+exports.GuardrailRegistry = _ts_decorate3([
+  common.Injectable(),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof core.DiscoveryService === "undefined" ? Object : core.DiscoveryService
+  ])
+], exports.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");
+exports.AgentRegistry = class AgentRegistry {
+  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()
+    ];
+  }
+};
+exports.AgentRegistry = _ts_decorate4([
+  common.Injectable(),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
+    typeof core.DiscoveryService === "undefined" ? Object : core.DiscoveryService
+  ])
+], exports.AgentRegistry);
+function createAgentTool(agent, options = {}) {
+  const schema = options.inputSchema ?? zod.z.object({
+    input: zod.z.string().describe("The task or question for the agent")
+  });
+  return ai.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(tool4) {
+    super(`Tool "${tool4}" was denied by the approval gate.`), this.tool = tool4;
+    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");
+exports.ToolRegistry = class ToolRegistry {
+  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 = ai.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
+    };
+  }
+};
+exports.ToolRegistry = _ts_decorate5([
+  common.Injectable(),
+  _ts_param3(3, common.Optional()),
+  _ts_param3(4, common.Optional()),
+  _ts_param3(5, common.Optional()),
+  _ts_param3(5, common.Inject(APPROVAL_GATE)),
+  _ts_param3(6, common.Optional()),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
+    typeof core.DiscoveryService === "undefined" ? Object : core.DiscoveryService,
+    typeof core.MetadataScanner === "undefined" ? Object : core.MetadataScanner,
+    typeof core.Reflector === "undefined" ? Object : core.Reflector,
+    typeof exports.AiEventEmitter === "undefined" ? Object : exports.AiEventEmitter,
+    typeof exports.GuardrailRegistry === "undefined" ? Object : exports.GuardrailRegistry,
+    typeof ApprovalGate === "undefined" ? Object : ApprovalGate,
+    typeof exports.AgentRegistry === "undefined" ? Object : exports.AgentRegistry
+  ])
+], exports.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");
+exports.AiService = class AiService {
+  static {
+    __name(this, "AiService");
+  }
+  providers;
+  toolRegistry;
+  constructor(providers, toolRegistry) {
+    this.providers = providers;
+    this.toolRegistry = toolRegistry;
+  }
+  generateText(params) {
+    return ai.generateText(this.resolve(params));
+  }
+  streamText(params) {
+    return ai.streamText(this.resolve(params));
+  }
+  generateObject(params) {
+    return ai.generateObject(this.resolve(params));
+  }
+  streamObject(params) {
+    return ai.streamObject(this.resolve(params));
+  }
+  resolve(params) {
+    const { model, tools, ...rest } = params;
+    return {
+      ...rest,
+      model: this.providers.getLanguageModel(model),
+      ...tools ? {
+        tools: this.toolRegistry.buildToolSet(tools)
+      } : {}
+    };
+  }
+};
+exports.AiService = _ts_decorate6([
+  common.Injectable(),
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("design:paramtypes", [
+    typeof exports.ProviderRegistry === "undefined" ? Object : exports.ProviderRegistry,
+    typeof exports.ToolRegistry === "undefined" ? Object : exports.ToolRegistry
+  ])
+], exports.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__";
+exports.PromptRegistry = class PromptRegistry {
+  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);
+  }
+};
+exports.PromptRegistry = _ts_decorate7([
+  common.Injectable()
+], exports.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");
+exports.UsageTracker = class UsageTracker {
+  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();
+    }
+  }
+};
+exports.UsageTracker = _ts_decorate8([
+  common.Injectable(),
+  _ts_param4(0, common.Inject(AI_MODULE_OPTIONS)),
+  _ts_param4(1, common.Optional()),
+  _ts_metadata7("design:type", Function),
+  _ts_metadata7("design:paramtypes", [
+    typeof AiModuleOptions === "undefined" ? Object : AiModuleOptions,
+    typeof exports.AiEventEmitter === "undefined" ? Object : exports.AiEventEmitter
+  ])
+], exports.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");
+exports.EmbeddingsService = class EmbeddingsService {
+  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 ai.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 ai.embedMany({
+      model: this.providers.getEmbeddingModel(options.model),
+      values,
+      abortSignal: options.abortSignal,
+      maxRetries: options.maxRetries
+    });
+  }
+};
+exports.EmbeddingsService = _ts_decorate9([
+  common.Injectable(),
+  _ts_param5(1, common.Optional()),
+  _ts_param5(1, common.Inject(AI_CACHE)),
+  _ts_metadata8("design:type", Function),
+  _ts_metadata8("design:paramtypes", [
+    typeof exports.ProviderRegistry === "undefined" ? Object : exports.ProviderRegistry,
+    typeof AiCache === "undefined" ? Object : AiCache
+  ])
+], exports.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");
+exports.SemanticMemory = class SemanticMemory {
+  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;
+  }
+};
+exports.SemanticMemory = _ts_decorate10([
+  common.Injectable(),
+  _ts_param6(1, common.Inject(VECTOR_STORE)),
+  _ts_param6(2, common.Optional()),
+  _ts_metadata9("design:type", Function),
+  _ts_metadata9("design:paramtypes", [
+    typeof exports.EmbeddingsService === "undefined" ? Object : exports.EmbeddingsService,
+    typeof VectorStore === "undefined" ? Object : VectorStore,
+    typeof exports.AiService === "undefined" ? Object : exports.AiService
+  ])
+], exports.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");
+exports.AgentExecutorService = class AgentExecutorService {
+  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 ai.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 ai.generateText({
+      model,
+      system,
+      messages,
+      tools: this.toolRegistry.buildToolSet(meta.tools),
+      stopWhen: ai.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 ai.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 ai.streamText({
+      model,
+      system,
+      messages: newMessages,
+      tools: this.toolRegistry.buildToolSet(meta.tools),
+      stopWhen: ai.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
+    ]);
+  }
+};
+exports.AgentExecutorService = _ts_decorate11([
+  common.Injectable(),
+  _ts_param7(2, common.Inject(CONVERSATION_STORE)),
+  _ts_param7(3, common.Inject(AI_MODULE_OPTIONS)),
+  _ts_param7(4, common.Optional()),
+  _ts_param7(5, common.Optional()),
+  _ts_param7(6, common.Optional()),
+  _ts_param7(7, common.Optional()),
+  _ts_param7(8, common.Optional()),
+  _ts_metadata10("design:type", Function),
+  _ts_metadata10("design:paramtypes", [
+    typeof exports.ProviderRegistry === "undefined" ? Object : exports.ProviderRegistry,
+    typeof exports.ToolRegistry === "undefined" ? Object : exports.ToolRegistry,
+    typeof ConversationStore === "undefined" ? Object : ConversationStore,
+    typeof AiModuleOptions === "undefined" ? Object : AiModuleOptions,
+    typeof exports.AiEventEmitter === "undefined" ? Object : exports.AiEventEmitter,
+    typeof exports.GuardrailRegistry === "undefined" ? Object : exports.GuardrailRegistry,
+    typeof exports.PromptRegistry === "undefined" ? Object : exports.PromptRegistry,
+    typeof exports.UsageTracker === "undefined" ? Object : exports.UsageTracker,
+    typeof exports.SemanticMemory === "undefined" ? Object : exports.SemanticMemory
+  ])
+], exports.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");
+exports.InMemoryConversationStore = class InMemoryConversationStore {
+  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);
+  }
+};
+exports.InMemoryConversationStore = _ts_decorate12([
+  common.Injectable()
+], exports.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");
+exports.ImageService = class ImageService {
+  static {
+    __name(this, "ImageService");
+  }
+  providers;
+  constructor(providers) {
+    this.providers = providers;
+  }
+  generate(prompt, options = {}) {
+    const { model, ...rest } = options;
+    return ai.generateImage({
+      model: this.providers.getImageModel(model),
+      prompt,
+      ...rest
+    });
+  }
+};
+exports.ImageService = _ts_decorate13([
+  common.Injectable(),
+  _ts_metadata11("design:type", Function),
+  _ts_metadata11("design:paramtypes", [
+    typeof exports.ProviderRegistry === "undefined" ? Object : exports.ProviderRegistry
+  ])
+], exports.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");
+exports.SpeechService = class SpeechService {
+  static {
+    __name(this, "SpeechService");
+  }
+  providers;
+  constructor(providers) {
+    this.providers = providers;
+  }
+  generate(text, options = {}) {
+    const { model, ...rest } = options;
+    return ai.experimental_generateSpeech({
+      model: this.providers.getSpeechModel(model),
+      text,
+      ...rest
+    });
+  }
+};
+exports.SpeechService = _ts_decorate14([
+  common.Injectable(),
+  _ts_metadata12("design:type", Function),
+  _ts_metadata12("design:paramtypes", [
+    typeof exports.ProviderRegistry === "undefined" ? Object : exports.ProviderRegistry
+  ])
+], exports.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");
+exports.TranscriptionService = class TranscriptionService {
+  static {
+    __name(this, "TranscriptionService");
+  }
+  providers;
+  constructor(providers) {
+    this.providers = providers;
+  }
+  transcribe(audio, options = {}) {
+    const { model, ...rest } = options;
+    return ai.experimental_transcribe({
+      model: this.providers.getTranscriptionModel(model),
+      audio,
+      ...rest
+    });
+  }
+};
+exports.TranscriptionService = _ts_decorate15([
+  common.Injectable(),
+  _ts_metadata13("design:type", Function),
+  _ts_metadata13("design:paramtypes", [
+    typeof exports.ProviderRegistry === "undefined" ? Object : exports.ProviderRegistry
+  ])
+], exports.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");
+exports.RagService = class RagService {
+  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);
+  }
+};
+exports.RagService = _ts_decorate16([
+  common.Injectable(),
+  _ts_param8(1, common.Inject(VECTOR_STORE)),
+  _ts_param8(2, common.Optional()),
+  _ts_param8(2, common.Inject(RERANKER)),
+  _ts_metadata14("design:type", Function),
+  _ts_metadata14("design:paramtypes", [
+    typeof exports.EmbeddingsService === "undefined" ? Object : exports.EmbeddingsService,
+    typeof VectorStore === "undefined" ? Object : VectorStore,
+    typeof Reranker === "undefined" ? Object : Reranker
+  ])
+], exports.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");
+exports.InMemoryVectorStore = class InMemoryVectorStore {
+  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: ai.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);
+  }
+};
+exports.InMemoryVectorStore = _ts_decorate17([
+  common.Injectable()
+], exports.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");
+exports.McpService = class McpService {
+  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] = ai.dynamicTool({
+        description: info.description ?? info.name,
+        inputSchema: ai.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();
+  }
+};
+exports.McpService = _ts_decorate18([
+  common.Injectable()
+], exports.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);
+    common.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";
+  }
+};
+exports.BudgetGuard = class BudgetGuard {
+  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);
+    }
+  }
+};
+exports.BudgetGuard = _ts_decorate19([
+  Guardrail(),
+  common.Injectable(),
+  _ts_param9(1, common.Inject(AI_MODULE_OPTIONS)),
+  _ts_metadata15("design:type", Function),
+  _ts_metadata15("design:paramtypes", [
+    typeof exports.UsageTracker === "undefined" ? Object : exports.UsageTracker,
+    typeof AiModuleOptions === "undefined" ? Object : AiModuleOptions
+  ])
+], exports.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");
+exports.RateLimitGuardrail = class RateLimitGuardrail {
+  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);
+    }
+  }
+};
+exports.RateLimitGuardrail = _ts_decorate20([
+  Guardrail(),
+  common.Injectable(),
+  _ts_param10(0, common.Inject(RATE_LIMITER)),
+  _ts_metadata16("design:type", Function),
+  _ts_metadata16("design:paramtypes", [
+    typeof RateLimiter === "undefined" ? Object : RateLimiter
+  ])
+], exports.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");
+exports.HeuristicReranker = class HeuristicReranker {
+  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
+    }));
+  }
+};
+exports.HeuristicReranker = _ts_decorate21([
+  common.Injectable(),
+  _ts_param11(0, common.Optional()),
+  _ts_metadata17("design:type", Function),
+  _ts_metadata17("design:paramtypes", [
+    typeof HeuristicRerankerOptions === "undefined" ? Object : HeuristicRerankerOptions
+  ])
+], exports.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");
+exports.EvalRunner = class EvalRunner {
+  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
+    };
+  }
+};
+exports.EvalRunner = _ts_decorate22([
+  common.Injectable()
+], exports.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");
+function createLlmJudge(ai, options = {}) {
+  const scale = options.scale ?? 5;
+  const passThreshold = options.passThreshold ?? 0.6;
+  return async ({ case: evalCase, output }) => {
+    const { object } = await ai.generateObject({
+      model: options.model,
+      schema: zod.z.object({
+        score: zod.z.number(),
+        reasoning: zod.z.string()
+      }),
+      prompt: `Rubric: ${evalCase.rubric ?? "Is the answer correct and helpful?"}
+Expected: ${evalCase.expected ?? "n/a"}
+Output: ${output}
+Give a score from 0 to ${scale} and a brief reasoning.`
+    });
+    const normalized = Math.max(0, Math.min(1, object.score / scale));
+    return {
+      score: normalized,
+      passed: normalized >= passThreshold,
+      reasoning: object.reasoning
+    };
+  };
+}
+__name(createLlmJudge, "createLlmJudge");
+
+// 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");
+exports.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: [
+          exports.PromptRegistry
+        ]
+      });
+    }
+    return {
+      module: _AiModule,
+      providers,
+      exports: providers
+    };
+  }
+  static build(optionsProvider, options, extraImports = []) {
+    return {
+      module: _AiModule,
+      imports: [
+        core.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 ? [
+          exports.BudgetGuard
+        ] : [],
+        ...options.rateLimiter ? [
+          exports.RateLimitGuardrail
+        ] : [],
+        ..._AiModule.coreProviders(),
+        _AiModule.initializerProvider()
+      ],
+      exports: _AiModule.exportedTokens()
+    };
+  }
+  static coreProviders() {
+    return [
+      exports.ProviderRegistry,
+      exports.ToolRegistry,
+      exports.AgentExecutorService,
+      exports.AgentRegistry,
+      exports.AiService,
+      exports.EmbeddingsService,
+      exports.ImageService,
+      exports.SpeechService,
+      exports.TranscriptionService,
+      exports.RagService,
+      exports.PromptRegistry,
+      exports.AiEventEmitter,
+      exports.GuardrailRegistry,
+      exports.McpService,
+      exports.UsageTracker,
+      exports.SemanticMemory,
+      exports.EvalRunner,
+      {
+        provide: RERANKER,
+        useFactory: /* @__PURE__ */ __name(() => new exports.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 [
+      exports.ProviderRegistry,
+      exports.ToolRegistry,
+      exports.AgentExecutorService,
+      exports.AgentRegistry,
+      exports.AiService,
+      exports.EmbeddingsService,
+      exports.ImageService,
+      exports.SpeechService,
+      exports.TranscriptionService,
+      exports.RagService,
+      exports.PromptRegistry,
+      exports.AiEventEmitter,
+      exports.GuardrailRegistry,
+      exports.McpService,
+      exports.UsageTracker,
+      exports.SemanticMemory,
+      exports.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: [
+        exports.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: [
+        core.ModuleRef
+      ]
+    };
+  }
+  static storeProvider(store) {
+    if (!store) {
+      return {
+        provide: CONVERSATION_STORE,
+        useClass: exports.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: exports.InMemoryVectorStore
+      };
+    }
+    if (typeof store === "function") {
+      return {
+        provide: VECTOR_STORE,
+        useClass: store
+      };
+    }
+    return {
+      provide: VECTOR_STORE,
+      ...store
+    };
+  }
+};
+exports.AiModule = _ts_decorate23([
+  common.Global(),
+  common.Module({})
+], exports.AiModule);
+function Tool(options) {
+  return (target, propertyKey, descriptor) => {
+    const metadata = {
+      ...options,
+      methodName: String(propertyKey)
+    };
+    Reflect.defineMetadata(TOOL_METADATA, metadata, descriptor.value);
+    return descriptor;
+  };
+}
+__name(Tool, "Tool");
+function Agent(options = {}) {
+  return (target) => {
+    Reflect.defineMetadata(AGENT_METADATA, options, target);
+    common.Injectable()(target);
+  };
+}
+__name(Agent, "Agent");
+function _ts_decorate24(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_decorate24, "_ts_decorate");
+function _ts_metadata18(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata18, "_ts_metadata");
+var AiAgent = class {
+  static {
+    __name(this, "AiAgent");
+  }
+  executor;
+  /** Runs the agent to completion. */
+  run(input, opts) {
+    return this.executor.run(this, input, opts);
+  }
+  /** Streams the agent's response (returns the raw Vercel stream result). */
+  stream(input, opts) {
+    return this.executor.stream(this, input, opts);
+  }
+};
+_ts_decorate24([
+  common.Inject(exports.AgentExecutorService),
+  _ts_metadata18("design:type", typeof exports.AgentExecutorService === "undefined" ? Object : exports.AgentExecutorService)
+], AiAgent.prototype, "executor", void 0);
+function createRetrievalTool(rag, options = {}) {
+  return ai.tool({
+    description: options.description ?? "Search the knowledge base for information relevant to the query.",
+    inputSchema: zod.z.object({
+      query: zod.z.string().describe("The search query")
+    }),
+    execute: /* @__PURE__ */ __name(async ({ query }) => {
+      const results = await rag.retrieve(query, {
+        topK: options.topK,
+        model: options.model,
+        filter: options.filter
+      });
+      if (results.length === 0) {
+        return "No relevant information found.";
+      }
+      return results.map((r, i) => `[${i + 1}] ${r.content}`).join("\n\n");
+    }, "execute")
+  });
+}
+__name(createRetrievalTool, "createRetrievalTool");
+
+// src/memory/adapters/prisma/prisma-conversation.store.ts
+var PrismaConversationStore = class {
+  static {
+    __name(this, "PrismaConversationStore");
+  }
+  delegate;
+  constructor(delegate) {
+    this.delegate = delegate;
+  }
+  async load(conversationId) {
+    const rows = await this.delegate.findMany({
+      where: {
+        conversationId
+      },
+      orderBy: {
+        position: "asc"
+      }
+    });
+    return rows.map((row) => ({
+      role: row.role,
+      content: row.content
+    }));
+  }
+  async append(conversationId, messages) {
+    if (messages.length === 0) {
+      return;
+    }
+    const base = await this.delegate.count({
+      where: {
+        conversationId
+      }
+    });
+    for (let index = 0; index < messages.length; index++) {
+      const message = messages[index];
+      await this.delegate.create({
+        data: {
+          conversationId,
+          role: message.role,
+          content: message.content,
+          position: base + index
+        }
+      });
+    }
+  }
+  async clear(conversationId) {
+    await this.delegate.deleteMany({
+      where: {
+        conversationId
+      }
+    });
+  }
+};
+function _ts_decorate25(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") 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_decorate25, "_ts_decorate");
+exports.InMemoryAiCache = class InMemoryAiCache {
+  static {
+    __name(this, "InMemoryAiCache");
+  }
+  store = /* @__PURE__ */ new Map();
+  async get(key) {
+    const entry = this.store.get(key);
+    if (!entry) {
+      return void 0;
+    }
+    if (entry.expiresAt !== null && entry.expiresAt <= Date.now()) {
+      this.store.delete(key);
+      return void 0;
+    }
+    return entry.value;
+  }
+  async set(key, value, ttlMs) {
+    this.store.set(key, {
+      value,
+      expiresAt: ttlMs != null ? Date.now() + ttlMs : null
+    });
+  }
+};
+exports.InMemoryAiCache = _ts_decorate25([
+  common.Injectable()
+], exports.InMemoryAiCache);
+function _ts_decorate26(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_decorate26, "_ts_decorate");
+exports.AutoApproveGate = class AutoApproveGate {
+  static {
+    __name(this, "AutoApproveGate");
+  }
+  async requestApproval(_context) {
+    return true;
+  }
+};
+exports.AutoApproveGate = _ts_decorate26([
+  common.Injectable()
+], exports.AutoApproveGate);
+exports.DenyApproveGate = class DenyApproveGate {
+  static {
+    __name(this, "DenyApproveGate");
+  }
+  async requestApproval(_context) {
+    return false;
+  }
+};
+exports.DenyApproveGate = _ts_decorate26([
+  common.Injectable()
+], exports.DenyApproveGate);
+
+// src/http/stream-response.ts
+function pipeAgentStream(result, res, options = {}) {
+  const protocol = options.protocol ?? "ui";
+  if (protocol === "text") {
+    if (typeof result.pipeTextStreamToResponse === "function") {
+      result.pipeTextStreamToResponse(res);
+      return;
+    }
+  } else if (typeof result.pipeUIMessageStreamToResponse === "function") {
+    result.pipeUIMessageStreamToResponse(res);
+    return;
+  }
+  throw new Error(`The stream result does not support the "${protocol}" protocol.`);
+}
+__name(pipeAgentStream, "pipeAgentStream");
+function _ts_decorate27(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_decorate27, "_ts_decorate");
+function _ts_metadata19(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata19, "_ts_metadata");
+exports.AgentStreamInterceptor = class AgentStreamInterceptor {
+  static {
+    __name(this, "AgentStreamInterceptor");
+  }
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  intercept(context, next) {
+    const res = context.switchToHttp().getResponse();
+    return next.handle().pipe(rxjs.mergeMap((result) => {
+      pipeAgentStream(result, res, this.options);
+      return rxjs.EMPTY;
+    }));
+  }
+};
+exports.AgentStreamInterceptor = _ts_decorate27([
+  common.Injectable(),
+  _ts_metadata19("design:type", Function),
+  _ts_metadata19("design:paramtypes", [
+    typeof PipeAgentStreamOptions === "undefined" ? Object : PipeAgentStreamOptions
+  ])
+], exports.AgentStreamInterceptor);
+function _ts_decorate28(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_decorate28, "_ts_decorate");
+function _ts_metadata20(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata20, "_ts_metadata");
+function _ts_param12(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param12, "_ts_param");
+var AGENT_JOB_NAME = "agent-run";
+exports.AgentQueueService = class AgentQueueService {
+  static {
+    __name(this, "AgentQueueService");
+  }
+  queue;
+  constructor(queue) {
+    this.queue = queue;
+  }
+  /** Enqueues an agent run and returns the created job id. */
+  async enqueue(data, jobOptions) {
+    const job = await this.queue.add(AGENT_JOB_NAME, data, jobOptions);
+    return job.id;
+  }
+};
+exports.AgentQueueService = _ts_decorate28([
+  common.Injectable(),
+  _ts_param12(0, common.Inject(AGENT_QUEUE)),
+  _ts_metadata20("design:type", Function),
+  _ts_metadata20("design:paramtypes", [
+    typeof QueueLike === "undefined" ? Object : QueueLike
+  ])
+], exports.AgentQueueService);
+function _ts_decorate29(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_decorate29, "_ts_decorate");
+function _ts_metadata21(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata21, "_ts_metadata");
+exports.AgentJobProcessor = class AgentJobProcessor {
+  static {
+    __name(this, "AgentJobProcessor");
+  }
+  agents;
+  constructor(agents) {
+    this.agents = agents;
+  }
+  async run(data) {
+    const agent = this.agents.get(data.agent);
+    if (!agent) {
+      throw new Error(`Cannot process job: unknown agent "${data.agent}". Is it registered?`);
+    }
+    return agent.run(data.input, data.options);
+  }
+};
+exports.AgentJobProcessor = _ts_decorate29([
+  common.Injectable(),
+  _ts_metadata21("design:type", Function),
+  _ts_metadata21("design:paramtypes", [
+    typeof exports.AgentRegistry === "undefined" ? Object : exports.AgentRegistry
+  ])
+], exports.AgentJobProcessor);
+
+// src/jobs/agent-jobs.module.ts
+function _ts_decorate30(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_decorate30, "_ts_decorate");
+function _ts_metadata22(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata22, "_ts_metadata");
+function _ts_param13(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param13, "_ts_param");
+var AGENT_JOBS_OPTIONS = /* @__PURE__ */ Symbol("AGENT_JOBS_OPTIONS");
+var DEFAULT_QUEUE = "ai-agent-runs";
+async function loadBullMq() {
+  const specifier = "bullmq";
+  return import(specifier);
+}
+__name(loadBullMq, "loadBullMq");
+var AgentWorkerManager = class AgentWorkerManager2 {
+  static {
+    __name(this, "AgentWorkerManager");
+  }
+  options;
+  processor;
+  worker;
+  constructor(options, processor) {
+    this.options = options;
+    this.processor = processor;
+  }
+  async onModuleInit() {
+    if (this.options.runWorker === false) {
+      return;
+    }
+    const { Worker } = await loadBullMq();
+    this.worker = new Worker(this.options.queueName ?? DEFAULT_QUEUE, async (job) => {
+      if (job.name === AGENT_JOB_NAME) {
+        return this.processor.run(job.data);
+      }
+      return void 0;
+    }, {
+      connection: this.options.connection
+    });
+  }
+  async onModuleDestroy() {
+    await this.worker?.close();
+  }
+};
+AgentWorkerManager = _ts_decorate30([
+  common.Injectable(),
+  _ts_param13(0, common.Inject(AGENT_JOBS_OPTIONS)),
+  _ts_metadata22("design:type", Function),
+  _ts_metadata22("design:paramtypes", [
+    typeof AgentJobsOptions === "undefined" ? Object : AgentJobsOptions,
+    typeof exports.AgentJobProcessor === "undefined" ? Object : exports.AgentJobProcessor
+  ])
+], AgentWorkerManager);
+exports.AgentJobsModule = class _AgentJobsModule {
+  static {
+    __name(this, "AgentJobsModule");
+  }
+  static forRoot(options) {
+    return {
+      module: _AgentJobsModule,
+      providers: [
+        {
+          provide: AGENT_JOBS_OPTIONS,
+          useValue: options
+        },
+        {
+          provide: AGENT_QUEUE,
+          useFactory: /* @__PURE__ */ __name(async () => {
+            const { Queue } = await loadBullMq();
+            return new Queue(options.queueName ?? DEFAULT_QUEUE, {
+              connection: options.connection
+            });
+          }, "useFactory")
+        },
+        exports.AgentQueueService,
+        exports.AgentJobProcessor,
+        AgentWorkerManager
+      ],
+      exports: [
+        exports.AgentQueueService,
+        exports.AgentJobProcessor
+      ]
+    };
+  }
+};
+exports.AgentJobsModule = _ts_decorate30([
+  common.Module({})
+], exports.AgentJobsModule);
+
+// src/rag/adapters/pgvector/pgvector-store.ts
+var PgVectorStore = class {
+  static {
+    __name(this, "PgVectorStore");
+  }
+  pool;
+  table;
+  constructor(pool, options = {}) {
+    this.pool = pool;
+    this.table = options.table ?? "ai_documents";
+  }
+  async upsert(documents) {
+    for (const doc of documents) {
+      if (!doc.embedding) {
+        throw new Error(`Document "${doc.id}" has no embedding. PgVectorStore requires precomputed embeddings (use RagService.ingest).`);
+      }
+      await this.pool.query(`INSERT INTO ${this.table} (id, content, embedding, metadata)
+         VALUES ($1, $2, $3, $4)
+         ON CONFLICT (id) DO UPDATE
+         SET content = EXCLUDED.content,
+             embedding = EXCLUDED.embedding,
+             metadata = EXCLUDED.metadata`, [
+        doc.id,
+        doc.content,
+        toVectorLiteral(doc.embedding),
+        doc.metadata ? JSON.stringify(doc.metadata) : null
+      ]);
+    }
+  }
+  async query(embedding, options = {}) {
+    const topK = options.topK ?? 4;
+    const vector = toVectorLiteral(embedding);
+    const params = [
+      vector
+    ];
+    let where = "";
+    if (options.filter) {
+      params.push(JSON.stringify(options.filter));
+      where = `WHERE metadata @> $${params.length}`;
+    }
+    params.push(topK);
+    const limitParam = `$${params.length}`;
+    const { rows } = await this.pool.query(`SELECT id, content, metadata, 1 - (embedding <=> $1) AS score
+       FROM ${this.table}
+       ${where}
+       ORDER BY embedding <=> $1
+       LIMIT ${limitParam}`, params);
+    return rows.map((row) => ({
+      id: row.id,
+      content: row.content,
+      score: Number(row.score),
+      metadata: row.metadata ?? void 0
+    }));
+  }
+  async delete(ids) {
+    if (ids.length === 0) {
+      return;
+    }
+    await this.pool.query(`DELETE FROM ${this.table} WHERE id = ANY($1)`, [
+      ids
+    ]);
+  }
+  async clear() {
+    await this.pool.query(`DELETE FROM ${this.table}`);
+  }
+};
+function toVectorLiteral(embedding) {
+  return `[${embedding.join(",")}]`;
+}
+__name(toVectorLiteral, "toVectorLiteral");
+
+// src/ratelimit/in-memory-rate-limiter.ts
+var InMemoryRateLimiter = class {
+  static {
+    __name(this, "InMemoryRateLimiter");
+  }
+  options;
+  buckets = /* @__PURE__ */ new Map();
+  now;
+  constructor(options) {
+    this.options = options;
+    this.now = options.now ?? Date.now;
+  }
+  async consume(key, cost = 1) {
+    const now = this.now();
+    const bucket = this.buckets.get(key) ?? {
+      tokens: this.options.capacity,
+      last: now
+    };
+    const elapsed = now - bucket.last;
+    if (elapsed > 0) {
+      const refill = elapsed / this.options.intervalMs * this.options.refillTokens;
+      bucket.tokens = Math.min(this.options.capacity, bucket.tokens + refill);
+      bucket.last = now;
+    }
+    let allowed = false;
+    if (bucket.tokens >= cost) {
+      bucket.tokens -= cost;
+      allowed = true;
+    }
+    this.buckets.set(key, bucket);
+    return allowed;
+  }
+};
+function _ts_decorate31(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_decorate31, "_ts_decorate");
+var DEFAULT_PII_PATTERNS = [
+  /[\w.+-]+@[\w-]+\.[\w.-]+/g,
+  /\b\d{3}-\d{2}-\d{4}\b/g,
+  /\b(?:\d[ -]*?){13,16}\b/g,
+  /(?:\+?\d[\d\s().-]{7,}\d)/g
+];
+function redactPii(text, patterns = DEFAULT_PII_PATTERNS, replacement = "[REDACTED]") {
+  let out = text;
+  for (const pattern of patterns) {
+    out = out.replace(pattern, replacement);
+  }
+  return out;
+}
+__name(redactPii, "redactPii");
+function redactMessages(messages, patterns = DEFAULT_PII_PATTERNS, replacement = "[REDACTED]") {
+  for (const message of messages) {
+    const content = message.content;
+    if (typeof content === "string") {
+      message.content = redactPii(content, patterns, replacement);
+    } else if (Array.isArray(content)) {
+      for (const part of content) {
+        if (part && typeof part === "object" && typeof part.text === "string") {
+          part.text = redactPii(part.text, patterns, replacement);
+        }
+      }
+    }
+  }
+}
+__name(redactMessages, "redactMessages");
+exports.PiiRedactionGuardrail = class PiiRedactionGuardrail {
+  static {
+    __name(this, "PiiRedactionGuardrail");
+  }
+  beforeRun(ctx) {
+    redactMessages(ctx.messages);
+  }
+};
+exports.PiiRedactionGuardrail = _ts_decorate31([
+  Guardrail(),
+  common.Injectable()
+], exports.PiiRedactionGuardrail);
+function createPiiRedactionGuardrail(options = {}) {
+  const patterns = options.patterns ?? DEFAULT_PII_PATTERNS;
+  const replacement = options.replacement ?? "[REDACTED]";
+  let ConfiguredPiiRedaction = class ConfiguredPiiRedaction {
+    static {
+      __name(this, "ConfiguredPiiRedaction");
+    }
+    beforeRun(ctx) {
+      redactMessages(ctx.messages, patterns, replacement);
+    }
+  };
+  ConfiguredPiiRedaction = _ts_decorate31([
+    Guardrail(),
+    common.Injectable()
+  ], ConfiguredPiiRedaction);
+  return ConfiguredPiiRedaction;
+}
+__name(createPiiRedactionGuardrail, "createPiiRedactionGuardrail");
+function _ts_decorate32(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_decorate32, "_ts_decorate");
+var ContentBlockedError = class extends Error {
+  static {
+    __name(this, "ContentBlockedError");
+  }
+  reason;
+  constructor(reason) {
+    super(`Content blocked by moderation: ${reason}`), this.reason = reason;
+    this.name = "ContentBlockedError";
+  }
+};
+function messagesText(messages) {
+  return messages.map((m) => {
+    const content = m.content;
+    if (typeof content === "string") {
+      return content;
+    }
+    if (Array.isArray(content)) {
+      return content.map((p) => p && typeof p.text === "string" ? p.text : "").join(" ");
+    }
+    return "";
+  }).join("\n");
+}
+__name(messagesText, "messagesText");
+function createModerationGuardrail(options = {}) {
+  const blocked = (options.blocked ?? []).map((t) => t.toLowerCase());
+  const moderate = options.moderate;
+  let ConfiguredModeration = class ConfiguredModeration {
+    static {
+      __name(this, "ConfiguredModeration");
+    }
+    async beforeRun(ctx) {
+      const text = messagesText(ctx.messages);
+      const lower = text.toLowerCase();
+      const hit = blocked.find((term) => lower.includes(term));
+      if (hit) {
+        throw new ContentBlockedError(`matched blocked term "${hit}"`);
+      }
+      if (moderate && await moderate(text)) {
+        throw new ContentBlockedError("failed custom moderation");
+      }
+    }
+  };
+  ConfiguredModeration = _ts_decorate32([
+    Guardrail(),
+    common.Injectable()
+  ], ConfiguredModeration);
+  return ConfiguredModeration;
+}
+__name(createModerationGuardrail, "createModerationGuardrail");
+function _ts_decorate33(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_decorate33, "_ts_decorate");
+function _ts_metadata23(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata23, "_ts_metadata");
+exports.ModelReranker = class ModelReranker {
+  static {
+    __name(this, "ModelReranker");
+  }
+  providers;
+  model;
+  constructor(providers, model) {
+    this.providers = providers;
+    this.model = model;
+  }
+  async rerank(query, results, topN) {
+    if (results.length === 0) {
+      return [];
+    }
+    const { ranking } = await ai.rerank({
+      model: this.providers.getRerankingModel(this.model),
+      query,
+      documents: results.map((r) => r.content),
+      topN
+    });
+    return ranking.map((entry) => ({
+      ...results[entry.originalIndex],
+      score: entry.score
+    }));
+  }
+};
+exports.ModelReranker = _ts_decorate33([
+  common.Injectable(),
+  _ts_metadata23("design:type", Function),
+  _ts_metadata23("design:paramtypes", [
+    typeof exports.ProviderRegistry === "undefined" ? Object : exports.ProviderRegistry,
+    String
+  ])
+], exports.ModelReranker);
+
+// src/rag/adapters/qdrant/qdrant-vector-store.ts
+var QdrantVectorStore = class {
+  static {
+    __name(this, "QdrantVectorStore");
+  }
+  client;
+  options;
+  constructor(client, options) {
+    this.client = client;
+    this.options = options;
+  }
+  async upsert(documents) {
+    await this.client.upsert(this.options.collection, {
+      wait: true,
+      points: documents.map((doc) => {
+        if (!doc.embedding) {
+          throw new Error(`Document "${doc.id}" has no embedding.`);
+        }
+        return {
+          id: doc.id,
+          vector: doc.embedding,
+          payload: {
+            content: doc.content,
+            ...doc.metadata
+          }
+        };
+      })
+    });
+  }
+  async query(embedding, options = {}) {
+    const results = await this.client.search(this.options.collection, {
+      vector: embedding,
+      limit: options.topK ?? 4,
+      with_payload: true,
+      filter: buildFilter(options.filter)
+    });
+    return results.map((hit) => {
+      const { content, ...metadata } = hit.payload ?? {};
+      return {
+        id: String(hit.id),
+        content: String(content ?? ""),
+        score: hit.score,
+        metadata: Object.keys(metadata).length ? metadata : void 0
+      };
+    });
+  }
+  async delete(ids) {
+    await this.client.delete(this.options.collection, {
+      points: ids
+    });
+  }
+  async clear() {
+    await this.client.delete(this.options.collection, {
+      filter: {}
+    });
+  }
+};
+function buildFilter(filter) {
+  if (!filter || Object.keys(filter).length === 0) {
+    return void 0;
+  }
+  return {
+    must: Object.entries(filter).map(([key, value]) => ({
+      key,
+      match: {
+        value
+      }
+    }))
+  };
+}
+__name(buildFilter, "buildFilter");
+
+// src/rag/adapters/pinecone/pinecone-vector-store.ts
+var PineconeVectorStore = class {
+  static {
+    __name(this, "PineconeVectorStore");
+  }
+  index;
+  constructor(index) {
+    this.index = index;
+  }
+  async upsert(documents) {
+    await this.index.upsert(documents.map((doc) => {
+      if (!doc.embedding) {
+        throw new Error(`Document "${doc.id}" has no embedding.`);
+      }
+      return {
+        id: doc.id,
+        values: doc.embedding,
+        metadata: {
+          content: doc.content,
+          ...doc.metadata
+        }
+      };
+    }));
+  }
+  async query(embedding, options = {}) {
+    const { matches } = await this.index.query({
+      vector: embedding,
+      topK: options.topK ?? 4,
+      includeMetadata: true,
+      filter: options.filter
+    });
+    return (matches ?? []).map((match) => {
+      const { content, ...metadata } = match.metadata ?? {};
+      return {
+        id: match.id,
+        content: String(content ?? ""),
+        score: match.score ?? 0,
+        metadata: Object.keys(metadata).length ? metadata : void 0
+      };
+    });
+  }
+  async delete(ids) {
+    await this.index.deleteMany(ids);
+  }
+  async clear() {
+    await this.index.deleteAll();
+  }
+};
+
+// src/websocket/stream-to-socket.ts
+async function streamAgentToSocket(stream, socket, options = {}) {
+  const chunkEvent = options.chunkEvent ?? "agent:chunk";
+  const doneEvent = options.doneEvent ?? "agent:done";
+  const errorEvent = options.errorEvent ?? "agent:error";
+  try {
+    let text = "";
+    for await (const delta of stream.textStream) {
+      text += delta;
+      socket.emit(chunkEvent, {
+        delta
+      });
+    }
+    socket.emit(doneEvent, {
+      text
+    });
+    return text;
+  } catch (error) {
+    socket.emit(errorEvent, {
+      message: error instanceof Error ? error.message : String(error)
+    });
+    throw error;
+  }
+}
+__name(streamAgentToSocket, "streamAgentToSocket");
+
+exports.AGENT_JOB_NAME = AGENT_JOB_NAME;
+exports.AGENT_QUEUE = AGENT_QUEUE;
+exports.AI_CACHE = AI_CACHE;
+exports.AI_EVENTS = AI_EVENTS;
+exports.AI_MODULE_OPTIONS = AI_MODULE_OPTIONS;
+exports.APPROVAL_GATE = APPROVAL_GATE;
+exports.Agent = Agent;
+exports.AiAgent = AiAgent;
+exports.BudgetExceededError = BudgetExceededError;
+exports.CONVERSATION_STORE = CONVERSATION_STORE;
+exports.ContentBlockedError = ContentBlockedError;
+exports.DEFAULT_MAX_STEPS = DEFAULT_MAX_STEPS;
+exports.DEFAULT_PII_PATTERNS = DEFAULT_PII_PATTERNS;
+exports.DEFAULT_PRICING = DEFAULT_PRICING;
+exports.EVENT_EMITTER = EVENT_EMITTER;
+exports.Guardrail = Guardrail;
+exports.InMemoryRateLimiter = InMemoryRateLimiter;
+exports.PgVectorStore = PgVectorStore;
+exports.PineconeVectorStore = PineconeVectorStore;
+exports.PrismaConversationStore = PrismaConversationStore;
+exports.QdrantVectorStore = QdrantVectorStore;
+exports.RATE_LIMITER = RATE_LIMITER;
+exports.RERANKER = RERANKER;
+exports.RateLimitedError = RateLimitedError;
+exports.Tool = Tool;
+exports.ToolApprovalDeniedError = ToolApprovalDeniedError;
+exports.VECTOR_STORE = VECTOR_STORE;
+exports.bareModelId = bareModelId;
+exports.cacheKey = cacheKey;
+exports.costOf = costOf;
+exports.createAgentTool = createAgentTool;
+exports.createCacheMiddleware = createCacheMiddleware;
+exports.createFallbackModel = createFallbackModel;
+exports.createLlmJudge = createLlmJudge;
+exports.createModerationGuardrail = createModerationGuardrail;
+exports.createPiiRedactionGuardrail = createPiiRedactionGuardrail;
+exports.createRetrievalTool = createRetrievalTool;
+exports.defaultJudge = defaultJudge;
+exports.interpolate = interpolate;
+exports.pipeAgentStream = pipeAgentStream;
+exports.redactMessages = redactMessages;
+exports.redactPii = redactPii;
+exports.splitText = splitText;
+exports.streamAgentToSocket = streamAgentToSocket;
+exports.toMessages = toMessages;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map