@dangao/bun-server 1.12.0 → 2.0.0

package/dist/index.js

@@ -4003,67 +4003,83 @@ class BunServer {
     this.isShuttingDown = false;
     this.shutdownPromise = undefined;
     this.shutdownResolve = undefined;
-    this.server = Bun.serve({
-      port: this.options.port ?? 3000,
-      hostname: this.options.hostname,
-      reusePort: this.options.reusePort,
-      fetch: (request, server) => {
-        if (this.isShuttingDown) {
-          return new Response("Server is shutting down", { status: 503 });
-        }
-        const upgradeHeader = request.headers.get("upgrade");
-        if (this.options.websocketRegistry && upgradeHeader && upgradeHeader.toLowerCase() === "websocket") {
-          const url = new URL(request.url);
-          if (!this.options.websocketRegistry.hasGateway(url.pathname)) {
-            return new Response("WebSocket gateway not found", { status: 404 });
-          }
-          const context2 = new Context(request);
-          const queryParams = new URLSearchParams(url.searchParams);
-          const upgraded = server.upgrade(request, {
-            data: {
-              path: url.pathname,
-              query: queryParams,
-              context: context2
-            }
-          });
-          if (upgraded) {
-            return;
+    const fetchHandler = (request, server) => {
+      if (this.isShuttingDown) {
+        return new Response("Server is shutting down", { status: 503 });
+      }
+      const upgradeHeader = request.headers.get("upgrade");
+      if (this.options.websocketRegistry && upgradeHeader && upgradeHeader.toLowerCase() === "websocket") {
+        const url = new URL(request.url);
+        if (!this.options.websocketRegistry.hasGateway(url.pathname)) {
+          return new Response("WebSocket gateway not found", { status: 404 });
+        }
+        const context2 = new Context(request);
+        const queryParams = new URLSearchParams(url.searchParams);
+        const upgraded = server.upgrade(request, {
+          data: {
+            path: url.pathname,
+            query: queryParams,
+            context: context2
           }
-          return new Response("WebSocket upgrade failed", { status: 400 });
-        }
-        this.activeRequests++;
-        const context = new Context(request);
-        const responsePromise = this.options.fetch(context);
-        if (responsePromise instanceof Promise) {
-          responsePromise.finally(() => {
-            this.activeRequests--;
-            if (this.isShuttingDown && this.activeRequests === 0 && this.shutdownResolve) {
-              this.shutdownResolve();
-            }
-          }).catch(() => {});
-        } else {
+        });
+        if (upgraded) {
+          return;
+        }
+        return new Response("WebSocket upgrade failed", { status: 400 });
+      }
+      this.activeRequests++;
+      const context = new Context(request);
+      const responsePromise = this.options.fetch(context);
+      if (responsePromise instanceof Promise) {
+        responsePromise.finally(() => {
           this.activeRequests--;
           if (this.isShuttingDown && this.activeRequests === 0 && this.shutdownResolve) {
             this.shutdownResolve();
           }
+        }).catch(() => {});
+      } else {
+        this.activeRequests--;
+        if (this.isShuttingDown && this.activeRequests === 0 && this.shutdownResolve) {
+          this.shutdownResolve();
         }
-        return responsePromise;
+      }
+      return responsePromise;
+    };
+    const websocketHandlers = {
+      open: async (ws) => {
+        await this.options.websocketRegistry?.handleOpen(ws);
       },
-      websocket: {
-        open: async (ws) => {
-          await this.options.websocketRegistry?.handleOpen(ws);
-        },
-        message: async (ws, message) => {
-          await this.options.websocketRegistry?.handleMessage(ws, message);
-        },
-        close: async (ws, code, reason) => {
-          await this.options.websocketRegistry?.handleClose(ws, code, reason);
-        }
+      message: async (ws, message) => {
+        await this.options.websocketRegistry?.handleMessage(ws, message);
+      },
+      close: async (ws, code, reason) => {
+        await this.options.websocketRegistry?.handleClose(ws, code, reason);
       }
-    });
-    const hostname = this.options.hostname ?? "localhost";
-    const port = this.server.port;
-    logger.info(`Server started at http://${hostname}:${port}`);
+    };
+    const socketFile = process.env.CLUSTER_SOCKET_FILE;
+    if (socketFile) {
+      this.server = Bun.serve({
+        unix: socketFile,
+        fetch: fetchHandler,
+        websocket: websocketHandlers
+      });
+      logger.info(`Server started at unix://${socketFile}`);
+    } else {
+      this.server = Bun.serve({
+        port: this.options.port ?? 3000,
+        hostname: this.options.hostname,
+        reusePort: this.options.reusePort,
+        fetch: fetchHandler,
+        websocket: websocketHandlers
+      });
+      const hostname = this.options.hostname ?? "localhost";
+      const port = this.server.port;
+      logger.info(`Server started at http://${hostname}:${port}`);
+      const portFile = process.env.CLUSTER_PORT_FILE;
+      if (portFile) {
+        Bun.write(portFile, String(port));
+      }
+    }
   }
   stop() {
     if (this.server) {
@@ -6322,6 +6338,9 @@ function applyDecorators(...decorators) {
 // src/core/cluster.ts
 var {spawn } = globalThis.Bun;
 import { LoggerManager as LoggerManager12 } from "@dangao/logsmith";
+import { tmpdir } from "os";
+import { join } from "path";
+import { mkdirSync, rmSync, existsSync } from "fs";
 
 class ClusterManager {
   workerCount;
@@ -6329,37 +6348,36 @@ class ClusterManager {
   scriptPath;
   port;
   hostname;
+  mode;
+  proxyServer;
+  socketPaths = [];
+  roundRobinIndex = 0;
+  socketDir;
   constructor(options) {
     this.workerCount = options.workers === "auto" ? navigator.hardwareConcurrency : options.workers;
     this.scriptPath = options.scriptPath;
     this.port = options.port;
     this.hostname = options.hostname;
+    const requestedMode = options.mode ?? "auto";
+    this.mode = requestedMode === "auto" ? "reusePort" : requestedMode;
   }
-  start() {
-    const logger = LoggerManager12.getLogger();
-    logger.info(`[Cluster] Starting ${this.workerCount} workers on port ${this.port}`);
-    for (let i = 0;i < this.workerCount; i++) {
-      const worker = spawn({
-        cmd: ["bun", "run", this.scriptPath],
-        env: {
-          ...process.env,
-          PORT: String(this.port),
-          REUSE_PORT: "1",
-          CLUSTER_WORKER: "1",
-          WORKER_ID: String(i),
-          ...this.hostname ? { HOSTNAME: this.hostname } : {}
-        },
-        stdout: "inherit",
-        stderr: "inherit"
-      });
-      this.workers.push(worker);
+  getMode() {
+    return this.mode;
+  }
+  async start() {
+    if (this.mode === "reusePort") {
+      this.startReusePort();
+    } else {
+      await this.startProxy();
     }
-    logger.info(`[Cluster] ${this.workerCount} workers started (reusePort mode)`);
-    this.monitorWorkers();
   }
   async stop() {
     const logger = LoggerManager12.getLogger();
     logger.info("[Cluster] Stopping all workers...");
+    if (this.proxyServer) {
+      this.proxyServer.stop();
+      this.proxyServer = undefined;
+    }
     for (const worker of this.workers) {
       worker.kill("SIGTERM");
     }
@@ -6371,29 +6389,151 @@ class ClusterManager {
     await Promise.all(this.workers.map((w) => w.exited));
     clearTimeout(timeout);
     this.workers.length = 0;
+    this.socketPaths.length = 0;
+    if (this.socketDir) {
+      try {
+        rmSync(this.socketDir, { recursive: true, force: true });
+      } catch {}
+      this.socketDir = undefined;
+    }
     logger.info("[Cluster] All workers stopped");
   }
-  monitorWorkers() {
+  startReusePort() {
+    const logger = LoggerManager12.getLogger();
+    logger.info(`[Cluster] Starting ${this.workerCount} workers on port ${this.port}`);
+    for (let i = 0;i < this.workerCount; i++) {
+      this.workers.push(this.spawnReusePortWorker(i));
+    }
+    logger.info(`[Cluster] ${this.workerCount} workers started (reusePort mode)`);
+    this.monitorReusePortWorkers();
+  }
+  spawnReusePortWorker(index) {
+    return spawn({
+      cmd: ["bun", "run", this.scriptPath],
+      env: {
+        ...process.env,
+        PORT: String(this.port),
+        REUSE_PORT: "1",
+        CLUSTER_WORKER: "1",
+        WORKER_ID: String(index),
+        ...this.hostname ? { HOSTNAME: this.hostname } : {}
+      },
+      stdout: "inherit",
+      stderr: "inherit"
+    });
+  }
+  monitorReusePortWorkers() {
     for (let i = 0;i < this.workers.length; i++) {
       const index = i;
       this.workers[index].exited.then((exitCode) => {
         if (exitCode !== 0 && exitCode !== null) {
           const logger = LoggerManager12.getLogger();
           logger.warn(`[Cluster] Worker ${index} exited with code ${exitCode}, restarting...`);
-          const newWorker = spawn({
-            cmd: ["bun", "run", this.scriptPath],
-            env: {
-              ...process.env,
-              PORT: String(this.port),
-              REUSE_PORT: "1",
-              CLUSTER_WORKER: "1",
-              WORKER_ID: String(index),
-              ...this.hostname ? { HOSTNAME: this.hostname } : {}
-            },
-            stdout: "inherit",
-            stderr: "inherit"
+          this.workers[index] = this.spawnReusePortWorker(index);
+        }
+      });
+    }
+  }
+  async startProxy() {
+    const logger = LoggerManager12.getLogger();
+    logger.info(`[Cluster] Starting ${this.workerCount} workers in proxy mode on port ${this.port}`);
+    this.socketDir = join(tmpdir(), `bun-cluster-${process.pid}`);
+    try {
+      rmSync(this.socketDir, { recursive: true, force: true });
+    } catch {}
+    mkdirSync(this.socketDir, { recursive: true });
+    this.socketPaths = [];
+    for (let i = 0;i < this.workerCount; i++) {
+      const socketPath = join(this.socketDir, `w${i}.sock`);
+      this.socketPaths.push(socketPath);
+      this.workers.push(this.spawnProxyWorker(i, socketPath));
+    }
+    await this.waitForWorkerSockets();
+    this.startProxyServer();
+    logger.info(`[Cluster] ${this.workerCount} workers ready (proxy mode, unix sockets)`);
+    this.monitorProxyWorkers();
+  }
+  spawnProxyWorker(index, socketPath) {
+    return spawn({
+      cmd: ["bun", "run", this.scriptPath],
+      env: {
+        ...process.env,
+        PORT: "0",
+        REUSE_PORT: "0",
+        CLUSTER_WORKER: "1",
+        WORKER_ID: String(index),
+        CLUSTER_MODE: "proxy",
+        CLUSTER_SOCKET_FILE: socketPath,
+        ...this.hostname ? { HOSTNAME: this.hostname } : {}
+      },
+      stdout: "inherit",
+      stderr: "inherit"
+    });
+  }
+  async waitForWorkerSockets() {
+    const deadline = Date.now() + 30000;
+    while (Date.now() < deadline) {
+      let allReady = true;
+      for (const socketPath of this.socketPaths) {
+        if (!existsSync(socketPath)) {
+          allReady = false;
+          break;
+        }
+      }
+      if (allReady) {
+        await Bun.sleep(200);
+        return;
+      }
+      await Bun.sleep(100);
+    }
+    const ready = this.socketPaths.filter((p) => existsSync(p)).length;
+    throw new Error(`[Cluster] Not all workers created sockets within 30s (got ${ready}/${this.workerCount})`);
+  }
+  startProxyServer() {
+    const sockets = this.socketPaths;
+    const count = sockets.length;
+    this.proxyServer = Bun.serve({
+      port: this.port,
+      hostname: this.hostname,
+      fetch: async (req) => {
+        const socketPath = sockets[this.roundRobinIndex % count];
+        this.roundRobinIndex++;
+        try {
+          return await fetch(req.url, {
+            method: req.method,
+            headers: req.headers,
+            body: req.body,
+            redirect: "manual",
+            unix: socketPath
           });
-          this.workers[index] = newWorker;
+        } catch {
+          return new Response("Bad Gateway", { status: 502 });
+        }
+      }
+    });
+  }
+  monitorProxyWorkers() {
+    for (let i = 0;i < this.workers.length; i++) {
+      const index = i;
+      this.workers[index].exited.then(async (exitCode) => {
+        if (exitCode !== 0 && exitCode !== null) {
+          const logger = LoggerManager12.getLogger();
+          logger.warn(`[Cluster] Worker ${index} exited with code ${exitCode}, restarting...`);
+          const socketPath = this.socketPaths[index];
+          try {
+            rmSync(socketPath);
+          } catch {}
+          this.workers[index] = this.spawnProxyWorker(index, socketPath);
+          const deadline = Date.now() + 15000;
+          while (Date.now() < deadline) {
+            if (existsSync(socketPath)) {
+              await Bun.sleep(200);
+              logger.info(`[Cluster] Worker ${index} restarted (unix socket)`);
+              return;
+            }
+            await Bun.sleep(100);
+          }
+          logger.error(`[Cluster] Worker ${index} failed to restart within 15s`);
         }
       });
     }
@@ -6404,6 +6544,11 @@ class ClusterManager {
   static getWorkerId() {
     return Number(process.env.WORKER_ID ?? -1);
   }
+  static getClusterMode() {
+    if (!ClusterManager.isWorker())
+      return null;
+    return process.env.CLUSTER_MODE === "proxy" ? "proxy" : "reusePort";
+  }
 }
 
 // src/index.ts
@@ -12920,12 +13065,2574 @@ class ServiceMetricsCollector {
     this.metricsIntegration?.stop();
   }
 }
+// src/ai/types.ts
+var AI_SERVICE_TOKEN = Symbol("@dangao/bun-server:ai:service");
+var AI_MODULE_OPTIONS_TOKEN = Symbol("@dangao/bun-server:ai:options");
+var AI_TOOL_REGISTRY_TOKEN = Symbol("@dangao/bun-server:ai:tool-registry");
+var AI_TOOL_METADATA_KEY = "@dangao/bun-server:ai:tool";
+// src/ai/errors.ts
+init_http_exception();
+
+class AiProviderError extends HttpException {
+  provider;
+  constructor(message, provider, statusCode = 502) {
+    super(statusCode, `[${provider}] ${message}`);
+    this.provider = provider;
+  }
+}
+
+class AiRateLimitError extends AiProviderError {
+  constructor(provider, retryAfterMs) {
+    super(retryAfterMs ? `Rate limit exceeded. Retry after ${retryAfterMs}ms` : "Rate limit exceeded", provider, 429);
+  }
+}
+
+class AiContextLengthError extends AiProviderError {
+  constructor(provider, maxTokens) {
+    super(maxTokens ? `Context length exceeded (max ${maxTokens} tokens)` : "Context length exceeded", provider, 413);
+  }
+}
+
+class AiTimeoutError extends AiProviderError {
+  constructor(provider, timeoutMs) {
+    super(`Request timed out after ${timeoutMs}ms`, provider, 504);
+  }
+}
+
+class AiNoProviderError extends HttpException {
+  constructor() {
+    super(500, "No AI providers configured. Call AiModule.forRoot() first.");
+  }
+}
+
+class AiAllProvidersFailed extends HttpException {
+  constructor(errors) {
+    super(502, `All AI providers failed: ${errors.join("; ")}`);
+  }
+}
+// src/ai/decorators.ts
+function AiTool(definition) {
+  return (target, propertyKey) => {
+    Reflect.defineMetadata(AI_TOOL_METADATA_KEY, definition, target, propertyKey);
+  };
+}
+// src/ai/service.ts
+init_decorators();
+init_decorators();
+
+// src/ai/tools/tool-executor.ts
+class ToolExecutor {
+  registry;
+  constructor(registry) {
+    this.registry = registry;
+  }
+  async executeAll(toolCalls) {
+    const results = await Promise.all(toolCalls.map((call) => this.executeOne(call)));
+    return results;
+  }
+  async executeOne(call) {
+    let content;
+    try {
+      const result = await this.registry.execute(call.name, call.arguments);
+      content = typeof result === "string" ? result : JSON.stringify(result, null, 2);
+    } catch (err) {
+      content = `Error executing tool "${call.name}": ${err instanceof Error ? err.message : String(err)}`;
+    }
+    return {
+      role: "tool",
+      content,
+      toolCallId: call.id
+    };
+  }
+}
+
+// src/ai/service.ts
+class AiService {
+  providers = new Map;
+  defaultProviderName;
+  options;
+  toolExecutor = null;
+  constructor(options) {
+    this.options = options;
+    for (const entry of options.providers) {
+      const provider = new entry.provider(entry.config);
+      this.providers.set(entry.name, provider);
+      if (entry.default || !this.defaultProviderName) {
+        this.defaultProviderName = entry.name;
+      }
+    }
+  }
+  setToolRegistry(registry) {
+    this.toolExecutor = new ToolExecutor(registry);
+  }
+  async complete(request) {
+    const maxIterations = this.options.tools?.maxIterations ?? 10;
+    let messages = [...request.messages];
+    let iteration = 0;
+    while (iteration < maxIterations) {
+      const response = await this.completeSingle({ ...request, messages });
+      if (!response.toolCalls || response.toolCalls.length === 0 || !this.toolExecutor) {
+        return response;
+      }
+      messages = [
+        ...messages,
+        { role: "assistant", content: response.content, toolCalls: response.toolCalls }
+      ];
+      const toolResults = await this.toolExecutor.executeAll(response.toolCalls);
+      messages = [...messages, ...toolResults];
+      iteration++;
+    }
+    return this.completeSingle({ ...request, messages, tools: [] });
+  }
+  stream(request) {
+    const provider = this.getProvider(request.provider);
+    return provider.stream(request);
+  }
+  countTokens(messages) {
+    const provider = this.getProvider();
+    return provider.countTokens(messages);
+  }
+  getProvider(name) {
+    const providerName = name ?? this.defaultProviderName;
+    if (!providerName)
+      throw new AiNoProviderError;
+    const provider = this.providers.get(providerName);
+    if (!provider)
+      throw new AiNoProviderError;
+    return provider;
+  }
+  getProviderNames() {
+    return Array.from(this.providers.keys());
+  }
+  async completeSingle(request) {
+    const targetName = request.provider ?? this.defaultProviderName;
+    if (!targetName)
+      throw new AiNoProviderError;
+    const fallback = this.options.fallback ?? false;
+    const timeout = this.options.timeout ?? 30000;
+    if (!fallback) {
+      return this.withTimeout(this.getProvider(targetName).complete(request), timeout, targetName);
+    }
+    const names = [
+      targetName,
+      ...Array.from(this.providers.keys()).filter((n) => n !== targetName)
+    ];
+    const errors = [];
+    for (const name of names) {
+      try {
+        const provider = this.providers.get(name);
+        if (!provider)
+          continue;
+        return await this.withTimeout(provider.complete({ ...request, provider: name }), timeout, name);
+      } catch (err) {
+        errors.push(`${name}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    throw new AiAllProvidersFailed(errors);
+  }
+  withTimeout(promise, ms, providerName) {
+    return new Promise((resolve2, reject) => {
+      const timer = setTimeout(() => reject(new AiTimeoutError(providerName, ms)), ms);
+      promise.then((val) => {
+        clearTimeout(timer);
+        resolve2(val);
+      }, (err) => {
+        clearTimeout(timer);
+        reject(err);
+      });
+    });
+  }
+}
+AiService = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyDecorateParamTS(0, Inject(AI_MODULE_OPTIONS_TOKEN)),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof AiModuleOptions === "undefined" ? Object : AiModuleOptions
+  ])
+], AiService);
+// src/ai/ai-module.ts
+init_module();
+
+// src/ai/tools/tool-registry.ts
+class ToolRegistry {
+  tools = new Map;
+  register(tool) {
+    this.tools.set(tool.name, tool);
+  }
+  scanAndRegister(instance) {
+    const proto = Object.getPrototypeOf(instance);
+    const methodNames = Object.getOwnPropertyNames(proto).filter((key) => key !== "constructor");
+    for (const methodName of methodNames) {
+      const metadata = Reflect.getMetadata(AI_TOOL_METADATA_KEY, proto, methodName);
+      if (metadata) {
+        const method = instance[methodName];
+        if (typeof method === "function") {
+          this.tools.set(metadata.name, {
+            ...metadata,
+            execute: (args) => method.call(instance, args)
+          });
+        }
+      }
+    }
+  }
+  getDefinitions() {
+    return Array.from(this.tools.values()).map(({ name, description, parameters }) => ({
+      name,
+      description,
+      parameters
+    }));
+  }
+  async execute(name, args) {
+    const tool = this.tools.get(name);
+    if (!tool) {
+      throw new Error(`Tool "${name}" not found in registry`);
+    }
+    return tool.execute(args);
+  }
+  has(name) {
+    return this.tools.has(name);
+  }
+  get size() {
+    return this.tools.size;
+  }
+}
+
+// src/ai/ai-module.ts
+class AiModule {
+  static forRoot(options) {
+    const toolRegistry = new ToolRegistry;
+    const aiService = new AiService(options);
+    aiService.setToolRegistry(toolRegistry);
+    const providers2 = [
+      { provide: AI_MODULE_OPTIONS_TOKEN, useValue: options },
+      { provide: AI_SERVICE_TOKEN, useValue: aiService },
+      { provide: AI_TOOL_REGISTRY_TOKEN, useValue: toolRegistry },
+      AiService
+    ];
+    const existing = Reflect.getMetadata(MODULE_METADATA_KEY, AiModule) || {};
+    Reflect.defineMetadata(MODULE_METADATA_KEY, {
+      ...existing,
+      providers: [...existing.providers || [], ...providers2],
+      exports: [
+        ...existing.exports || [],
+        AI_SERVICE_TOKEN,
+        AI_TOOL_REGISTRY_TOKEN,
+        AiService
+      ]
+    }, AiModule);
+    return AiModule;
+  }
+  static reset() {
+    Reflect.deleteMetadata(MODULE_METADATA_KEY, AiModule);
+  }
+}
+AiModule = __legacyDecorateClassTS([
+  Module({ providers: [] })
+], AiModule);
+// src/ai/providers/openai-provider.ts
+var DEFAULT_PRICING = {
+  "gpt-4o": { input: 2.5, output: 10 },
+  "gpt-4o-mini": { input: 0.15, output: 0.6 },
+  "gpt-4-turbo": { input: 10, output: 30 },
+  "gpt-3.5-turbo": { input: 0.5, output: 1.5 }
+};
+
+class OpenAIProvider {
+  name = "openai";
+  apiKey;
+  baseUrl;
+  defaultModel;
+  pricing;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = (config.baseUrl ?? "https://api.openai.com/v1").replace(/\/$/, "");
+    this.defaultModel = config.defaultModel ?? "gpt-4o";
+    this.pricing = { ...DEFAULT_PRICING, ...config.pricing ?? {} };
+  }
+  async complete(request) {
+    const model = request.model ?? this.defaultModel;
+    const body = {
+      model,
+      messages: request.messages,
+      temperature: request.temperature,
+      max_tokens: request.maxTokens
+    };
+    if (request.tools && request.tools.length > 0) {
+      body["tools"] = request.tools.map((t) => ({
+        type: "function",
+        function: { name: t.name, description: t.description, parameters: t.parameters }
+      }));
+    }
+    const response = await this.post("/chat/completions", body);
+    const choice = response.choices?.[0];
+    const usage = response.usage ?? { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 };
+    const message = choice?.message;
+    return {
+      content: message?.content ?? "",
+      toolCalls: message?.tool_calls?.map((tc) => ({
+        id: tc.id ?? "",
+        name: tc.function?.name ?? "",
+        arguments: this.safeParseToolArguments(tc.function?.arguments)
+      })),
+      model,
+      provider: this.name,
+      usage: {
+        promptTokens: usage.prompt_tokens ?? 0,
+        completionTokens: usage.completion_tokens ?? 0,
+        totalTokens: usage.total_tokens ?? 0,
+        estimatedCostUsd: this.estimateCost(model, usage.prompt_tokens ?? 0, usage.completion_tokens ?? 0)
+      },
+      finishReason: choice?.finish_reason === "tool_calls" ? "tool_calls" : "stop"
+    };
+  }
+  stream(request) {
+    const model = request.model ?? this.defaultModel;
+    const body = {
+      model,
+      messages: request.messages,
+      temperature: request.temperature,
+      max_tokens: request.maxTokens,
+      stream: true
+    };
+    if (request.tools && request.tools.length > 0) {
+      body["tools"] = request.tools.map((t) => ({
+        type: "function",
+        function: { name: t.name, description: t.description, parameters: t.parameters }
+      }));
+    }
+    const encoder = new TextEncoder;
+    const apiKey = this.apiKey;
+    const baseUrl = this.baseUrl;
+    return new ReadableStream({
+      async start(controller2) {
+        try {
+          const res = await fetch(`${baseUrl}/chat/completions`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${apiKey}`
+            },
+            body: JSON.stringify(body)
+          });
+          if (!res.ok || !res.body) {
+            const err = await res.text();
+            controller2.enqueue(encoder.encode(`data: ${JSON.stringify({ error: err, done: true })}
+
+`));
+            controller2.close();
+            return;
+          }
+          const reader = res.body.getReader();
+          const dec = new TextDecoder;
+          let buf = "";
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+              break;
+            buf += dec.decode(value, { stream: true });
+            const lines = buf.split(`
+`);
+            buf = lines.pop() ?? "";
+            for (const line of lines) {
+              if (line.startsWith("data: ")) {
+                const data = line.slice(6).trim();
+                if (data === "[DONE]") {
+                  controller2.enqueue(encoder.encode(`data: ${JSON.stringify({ done: true })}
+
+`));
+                  continue;
+                }
+                try {
+                  const parsed = JSON.parse(data);
+                  const delta = parsed.choices?.[0]?.delta;
+                  const chunk = { content: delta?.content ?? "", done: false };
+                  controller2.enqueue(encoder.encode(`data: ${JSON.stringify(chunk)}
+
+`));
+                } catch {}
+              }
+            }
+          }
+        } catch (err) {
+          controller2.enqueue(encoder.encode(`data: ${JSON.stringify({ error: String(err), done: true })}
+
+`));
+        } finally {
+          controller2.close();
+        }
+      }
+    });
+  }
+  countTokens(messages) {
+    return Math.ceil(messages.reduce((sum, m) => sum + m.content.length, 0) / 4);
+  }
+  async post(path, body) {
+    const res = await fetch(`${this.baseUrl}${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (res.status === 429) {
+      const retryAfter = res.headers.get("retry-after");
+      throw new AiRateLimitError(this.name, retryAfter ? Number(retryAfter) * 1000 : undefined);
+    }
+    if (res.status === 413) {
+      throw new AiContextLengthError(this.name);
+    }
+    if (res.status === 408 || res.status === 504) {
+      throw new AiTimeoutError(this.name, 30000);
+    }
+    if (!res.ok) {
+      const text = await res.text();
+      throw new AiProviderError(text, this.name, res.status);
+    }
+    return await res.json();
+  }
+  safeParseToolArguments(argumentsJson) {
+    if (!argumentsJson) {
+      return {};
+    }
+    try {
+      const parsed = JSON.parse(argumentsJson);
+      if (typeof parsed === "object" && parsed !== null) {
+        return parsed;
+      }
+      return {};
+    } catch {
+      return {};
+    }
+  }
+  estimateCost(model, promptTokens, completionTokens) {
+    const pricing = this.pricing[model];
+    if (!pricing)
+      return 0;
+    return (promptTokens * pricing.input + completionTokens * pricing.output) / 1e6;
+  }
+}
+// src/ai/providers/anthropic-provider.ts
+class AnthropicProvider {
+  name = "anthropic";
+  apiKey;
+  baseUrl;
+  defaultModel;
+  anthropicVersion;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = (config.baseUrl ?? "https://api.anthropic.com").replace(/\/$/, "");
+    this.defaultModel = config.defaultModel ?? "claude-3-7-sonnet-20250219";
+    this.anthropicVersion = config.anthropicVersion ?? "2023-06-01";
+  }
+  async complete(request) {
+    const model = request.model ?? this.defaultModel;
+    const systemMessages = request.messages.filter((m) => m.role === "system");
+    const chatMessages = request.messages.filter((m) => m.role !== "system");
+    const body = {
+      model,
+      messages: chatMessages.map((m) => ({
+        role: m.role === "tool" ? "user" : m.role,
+        content: m.role === "tool" ? [{ type: "tool_result", tool_use_id: m.toolCallId, content: m.content }] : m.content
+      })),
+      max_tokens: request.maxTokens ?? 4096,
+      temperature: request.temperature
+    };
+    if (systemMessages.length > 0) {
+      body["system"] = systemMessages.map((m) => m.content).join(`
+`);
+    }
+    if (request.tools && request.tools.length > 0) {
+      body["tools"] = request.tools.map((t) => ({
+        name: t.name,
+        description: t.description,
+        input_schema: t.parameters
+      }));
+    }
+    const response = await this.post("/v1/messages", body);
+    const usage = response["usage"] ?? { input_tokens: 0, output_tokens: 0 };
+    let content = "";
+    const toolCalls = [];
+    const contentBlocks = response["content"];
+    for (const block of contentBlocks) {
+      if (block["type"] === "text")
+        content += block["text"];
+      else if (block["type"] === "tool_use") {
+        toolCalls.push({
+          id: block["id"],
+          name: block["name"],
+          arguments: block["input"]
+        });
+      }
+    }
+    return {
+      content,
+      toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+      model,
+      provider: this.name,
+      usage: {
+        promptTokens: usage.input_tokens,
+        completionTokens: usage.output_tokens,
+        totalTokens: usage.input_tokens + usage.output_tokens
+      },
+      finishReason: response["stop_reason"] === "tool_use" ? "tool_calls" : "stop"
+    };
+  }
+  stream(request) {
+    const model = request.model ?? this.defaultModel;
+    const systemMessages = request.messages.filter((m) => m.role === "system");
+    const chatMessages = request.messages.filter((m) => m.role !== "system");
+    const body = {
+      model,
+      messages: chatMessages.map((m) => ({ role: m.role, content: m.content })),
+      max_tokens: request.maxTokens ?? 4096,
+      temperature: request.temperature,
+      stream: true
+    };
+    if (systemMessages.length > 0) {
+      body["system"] = systemMessages.map((m) => m.content).join(`
+`);
+    }
+    const apiKey = this.apiKey;
+    const baseUrl = this.baseUrl;
+    const anthropicVersion = this.anthropicVersion;
+    const encoder = new TextEncoder;
+    return new ReadableStream({
+      async start(controller2) {
+        try {
+          const res = await fetch(`${baseUrl}/v1/messages`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "x-api-key": apiKey,
+              "anthropic-version": anthropicVersion
+            },
+            body: JSON.stringify(body)
+          });
+          if (!res.ok || !res.body) {
+            controller2.enqueue(encoder.encode(`data: ${JSON.stringify({ error: await res.text(), done: true })}
+
+`));
+            controller2.close();
+            return;
+          }
+          const reader = res.body.getReader();
+          const dec = new TextDecoder;
+          let buf = "";
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+              break;
+            buf += dec.decode(value, { stream: true });
+            const lines = buf.split(`
+`);
+            buf = lines.pop() ?? "";
+            for (const line of lines) {
+              if (line.startsWith("data: ")) {
+                try {
+                  const parsed = JSON.parse(line.slice(6));
+                  if (parsed.type === "content_block_delta") {
+                    controller2.enqueue(encoder.encode(`data: ${JSON.stringify({ content: parsed.delta?.text ?? "", done: false })}
+
+`));
+                  } else if (parsed.type === "message_stop") {
+                    controller2.enqueue(encoder.encode(`data: ${JSON.stringify({ done: true })}
+
+`));
+                  }
+                } catch {}
+              }
+            }
+          }
+        } catch (err) {
+          controller2.enqueue(encoder.encode(`data: ${JSON.stringify({ error: String(err), done: true })}
+
+`));
+        } finally {
+          controller2.close();
+        }
+      }
+    });
+  }
+  countTokens(messages) {
+    return Math.ceil(messages.reduce((sum, m) => sum + m.content.length, 0) / 4);
+  }
+  async post(path, body) {
+    const res = await fetch(`${this.baseUrl}${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": this.apiKey,
+        "anthropic-version": this.anthropicVersion
+      },
+      body: JSON.stringify(body)
+    });
+    if (res.status === 429)
+      throw new AiRateLimitError(this.name);
+    if (res.status === 413)
+      throw new AiContextLengthError(this.name);
+    if (!res.ok)
+      throw new AiProviderError(await res.text(), this.name, res.status);
+    return res.json();
+  }
+}
+// src/ai/providers/ollama-provider.ts
+class OllamaProvider {
+  name = "ollama";
+  baseUrl;
+  defaultModel;
+  constructor(config = {}) {
+    this.baseUrl = (config.baseUrl ?? "http://localhost:11434").replace(/\/$/, "");
+    this.defaultModel = config.defaultModel ?? "llama3.2";
+  }
+  async complete(request) {
+    const model = request.model ?? this.defaultModel;
+    const res = await fetch(`${this.baseUrl}/api/chat`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model,
+        messages: request.messages.map((m) => ({ role: m.role, content: m.content })),
+        stream: false,
+        options: {
+          temperature: request.temperature,
+          num_predict: request.maxTokens
+        }
+      })
+    });
+    if (!res.ok) {
+      throw new AiProviderError(await res.text(), this.name, res.status);
+    }
+    const data = await res.json();
+    const message = data["message"];
+    const evalCount = data["eval_count"] ?? 0;
+    const promptEvalCount = data["prompt_eval_count"] ?? 0;
+    return {
+      content: message["content"] ?? "",
+      model,
+      provider: this.name,
+      usage: {
+        promptTokens: promptEvalCount,
+        completionTokens: evalCount,
+        totalTokens: promptEvalCount + evalCount
+      },
+      finishReason: "stop"
+    };
+  }
+  stream(request) {
+    const model = request.model ?? this.defaultModel;
+    const baseUrl = this.baseUrl;
+    const encoder = new TextEncoder;
+    return new ReadableStream({
+      async start(controller2) {
+        try {
+          const res = await fetch(`${baseUrl}/api/chat`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              model,
+              messages: request.messages.map((m) => ({ role: m.role, content: m.content })),
+              stream: true,
+              options: {
+                temperature: request.temperature,
+                num_predict: request.maxTokens
+              }
+            })
+          });
+          if (!res.ok || !res.body) {
+            controller2.enqueue(encoder.encode(`data: ${JSON.stringify({ error: await res.text(), done: true })}
+
+`));
+            controller2.close();
+            return;
+          }
+          const reader = res.body.getReader();
+          const dec = new TextDecoder;
+          let buf = "";
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+              break;
+            buf += dec.decode(value, { stream: true });
+            const lines = buf.split(`
+`);
+            buf = lines.pop() ?? "";
+            for (const line of lines) {
+              if (!line.trim())
+                continue;
+              try {
+                const parsed = JSON.parse(line);
+                const msgContent = parsed["message"]?.["content"] ?? "";
+                const isDone = Boolean(parsed["done"]);
+                controller2.enqueue(encoder.encode(`data: ${JSON.stringify({ content: msgContent, done: isDone })}
+
+`));
+              } catch {}
+            }
+          }
+        } catch (err) {
+          controller2.enqueue(encoder.encode(`data: ${JSON.stringify({ error: String(err), done: true })}
+
+`));
+        } finally {
+          controller2.close();
+        }
+      }
+    });
+  }
+  countTokens(messages) {
+    return Math.ceil(messages.reduce((sum, m) => sum + m.content.length, 0) / 4);
+  }
+}
+// src/ai/providers/google-provider.ts
+class GoogleProvider {
+  name = "google";
+  apiKey;
+  defaultModel;
+  baseUrl;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.defaultModel = config.defaultModel ?? "gemini-2.0-flash";
+    this.baseUrl = (config.baseUrl ?? "https://generativelanguage.googleapis.com/v1beta").replace(/\/$/, "");
+  }
+  async complete(request) {
+    const model = request.model ?? this.defaultModel;
+    const { contents, systemInstruction } = this.toGeminiMessages(request.messages);
+    const body = {
+      contents,
+      generationConfig: {
+        temperature: request.temperature,
+        maxOutputTokens: request.maxTokens
+      }
+    };
+    if (systemInstruction)
+      body["system_instruction"] = { parts: [{ text: systemInstruction }] };
+    if (request.tools && request.tools.length > 0) {
+      body["tools"] = [{
+        functionDeclarations: request.tools.map((t) => ({
+          name: t.name,
+          description: t.description,
+          parameters: t.parameters
+        }))
+      }];
+    }
+    const res = await fetch(`${this.baseUrl}/models/${model}:generateContent?key=${this.apiKey}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (res.status === 429)
+      throw new AiRateLimitError(this.name);
+    if (!res.ok)
+      throw new AiProviderError(await res.text(), this.name, res.status);
+    const data = await res.json();
+    const candidate = data["candidates"]?.[0];
+    const parts = candidate?.["content"]?.["parts"] ?? [];
+    let content = "";
+    const toolCalls = [];
+    for (const part of parts) {
+      if (part["text"])
+        content += part["text"];
+      else if (part["functionCall"]) {
+        const fc = part["functionCall"];
+        toolCalls.push({
+          id: `fc-${Date.now()}`,
+          name: fc["name"],
+          arguments: fc["args"]
+        });
+      }
+    }
+    const usageMeta = data["usageMetadata"] ?? {};
+    return {
+      content,
+      toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+      model,
+      provider: this.name,
+      usage: {
+        promptTokens: usageMeta["promptTokenCount"] ?? 0,
+        completionTokens: usageMeta["candidatesTokenCount"] ?? 0,
+        totalTokens: usageMeta["totalTokenCount"] ?? 0
+      },
+      finishReason: toolCalls.length > 0 ? "tool_calls" : "stop"
+    };
+  }
+  stream(request) {
+    const model = request.model ?? this.defaultModel;
+    const { contents, systemInstruction } = this.toGeminiMessages(request.messages);
+    const apiKey = this.apiKey;
+    const baseUrl = this.baseUrl;
+    const encoder = new TextEncoder;
+    const body = {
+      contents,
+      generationConfig: { temperature: request.temperature, maxOutputTokens: request.maxTokens }
+    };
+    if (systemInstruction)
+      body["system_instruction"] = { parts: [{ text: systemInstruction }] };
+    return new ReadableStream({
+      async start(controller2) {
+        try {
+          const res = await fetch(`${baseUrl}/models/${model}:streamGenerateContent?key=${apiKey}&alt=sse`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body)
+          });
+          if (!res.ok || !res.body) {
+            controller2.enqueue(encoder.encode(`data: ${JSON.stringify({ error: await res.text(), done: true })}
+
+`));
+            controller2.close();
+            return;
+          }
+          const reader = res.body.getReader();
+          const dec = new TextDecoder;
+          let buf = "";
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+              break;
+            buf += dec.decode(value, { stream: true });
+            const lines = buf.split(`
+`);
+            buf = lines.pop() ?? "";
+            for (const line of lines) {
+              if (line.startsWith("data: ")) {
+                try {
+                  const parsed = JSON.parse(line.slice(6));
+                  const candidate = parsed["candidates"]?.[0];
+                  const parts = candidate?.["content"]?.["parts"] ?? [];
+                  const text = parts.map((p) => p["text"] ?? "").join("");
+                  controller2.enqueue(encoder.encode(`data: ${JSON.stringify({ content: text, done: false })}
+
+`));
+                } catch {}
+              }
+            }
+          }
+          controller2.enqueue(encoder.encode(`data: ${JSON.stringify({ done: true })}
+
+`));
+        } catch (err) {
+          controller2.enqueue(encoder.encode(`data: ${JSON.stringify({ error: String(err), done: true })}
+
+`));
+        } finally {
+          controller2.close();
+        }
+      }
+    });
+  }
+  countTokens(messages) {
+    return Math.ceil(messages.reduce((sum, m) => sum + m.content.length, 0) / 4);
+  }
+  toGeminiMessages(messages) {
+    const systemParts = messages.filter((m) => m.role === "system").map((m) => m.content);
+    const chatMessages = messages.filter((m) => m.role !== "system");
+    const contents = chatMessages.map((m) => ({
+      role: m.role === "assistant" ? "model" : "user",
+      parts: [{ text: m.content }]
+    }));
+    return {
+      contents,
+      systemInstruction: systemParts.length > 0 ? systemParts.join(`
+`) : undefined
+    };
+  }
+}
+// src/conversation/types.ts
+var CONVERSATION_SERVICE_TOKEN = Symbol("@dangao/bun-server:conversation:service");
+var CONVERSATION_OPTIONS_TOKEN = Symbol("@dangao/bun-server:conversation:options");
+// src/conversation/service.ts
+init_decorators();
+init_decorators();
+class ConversationService {
+  store;
+  maxMessages;
+  autoTrim;
+  summaryThreshold;
+  constructor(options) {
+    this.store = options.store;
+    this.maxMessages = options.maxMessages ?? 100;
+    this.autoTrim = options.autoTrim ?? true;
+    this.summaryThreshold = options.summaryThreshold;
+  }
+  async create(metadata) {
+    return this.store.create(metadata);
+  }
+  async get(id) {
+    return this.store.get(id);
+  }
+  async getHistory(id) {
+    const conv = await this.store.get(id);
+    return conv?.messages ?? [];
+  }
+  async appendMessage(id, message, options) {
+    await this.store.appendMessage(id, message);
+    const opts = options ?? {};
+    const summarizer = opts.summarizer;
+    const summaryThreshold = this.summaryThreshold;
+    if (summaryThreshold && summarizer) {
+      const conv = await this.store.get(id);
+      if (conv && conv.messages.length >= summaryThreshold) {
+        await this.summarizeAndCompress(id, conv.messages, summarizer);
+        return;
+      }
+    }
+    if (this.autoTrim) {
+      await this.store.trim(id, this.maxMessages);
+    }
+  }
+  async delete(id) {
+    return this.store.delete(id);
+  }
+  async list() {
+    return this.store.list();
+  }
+  async summarize(id, summarizer) {
+    const conv = await this.store.get(id);
+    if (!conv)
+      return;
+    await this.summarizeAndCompress(id, conv.messages, summarizer);
+  }
+  async summarizeAndCompress(id, messages, summarizer) {
+    const keepCount = Math.floor(this.maxMessages / 4);
+    const toSummarize = messages.slice(0, -keepCount);
+    const toKeep = messages.slice(-keepCount);
+    if (toSummarize.length === 0)
+      return;
+    try {
+      const summary = await summarizer(toSummarize);
+      const summaryMessage = {
+        role: "system",
+        content: `[Conversation summary: ${summary}]`
+      };
+      const conv = await this.store.get(id);
+      if (!conv)
+        return;
+      const newMessages = [summaryMessage, ...toKeep];
+      for (const _msg of conv.messages) {
+        await this.store.trim(id, 0);
+      }
+      for (const msg of newMessages) {
+        await this.store.appendMessage(id, msg);
+      }
+    } catch {
+      await this.store.trim(id, this.maxMessages);
+    }
+  }
+}
+ConversationService = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyDecorateParamTS(0, Inject(CONVERSATION_OPTIONS_TOKEN)),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof ConversationModuleOptions === "undefined" ? Object : ConversationModuleOptions
+  ])
+], ConversationService);
+// src/conversation/decorators.ts
+function InjectConversation() {
+  return (target, propertyKey, parameterIndex) => {
+    const existing = Reflect.getMetadata("conversation:inject:params", target, propertyKey) ?? [];
+    existing.push(parameterIndex);
+    Reflect.defineMetadata("conversation:inject:params", existing, target, propertyKey);
+  };
+}
+function extractConversationId(ctx) {
+  const url = new URL(ctx.request.url);
+  const fromQuery = url.searchParams.get("conversationId");
+  if (fromQuery)
+    return fromQuery;
+  const fromHeader = ctx.request.headers.get("x-conversation-id");
+  if (fromHeader)
+    return fromHeader;
+  return;
+}
+// src/conversation/conversation-module.ts
+init_module();
+
+// src/conversation/stores/memory-store.ts
+class MemoryConversationStore {
+  conversations = new Map;
+  async create(metadata = {}) {
+    const id = crypto.randomUUID();
+    const conversation = {
+      id,
+      messages: [],
+      metadata,
+      createdAt: new Date,
+      updatedAt: new Date
+    };
+    this.conversations.set(id, conversation);
+    return { ...conversation, messages: [] };
+  }
+  async get(id) {
+    const conv = this.conversations.get(id);
+    if (!conv)
+      return null;
+    return { ...conv, messages: [...conv.messages] };
+  }
+  async appendMessage(id, message) {
+    const conv = this.conversations.get(id);
+    if (!conv)
+      throw new Error(`Conversation "${id}" not found`);
+    conv.messages.push(message);
+    conv.updatedAt = new Date;
+  }
+  async trim(id, maxMessages) {
+    const conv = this.conversations.get(id);
+    if (!conv)
+      return;
+    if (conv.messages.length > maxMessages) {
+      conv.messages = conv.messages.slice(-maxMessages);
+      conv.updatedAt = new Date;
+    }
+  }
+  async delete(id) {
+    return this.conversations.delete(id);
+  }
+  async list() {
+    return Array.from(this.conversations.keys());
+  }
+  get size() {
+    return this.conversations.size;
+  }
+}
+
+// src/conversation/conversation-module.ts
+class ConversationModule {
+  static forRoot(options = {}) {
+    const resolvedOptions = {
+      ...options,
+      store: options.store ?? new MemoryConversationStore
+    };
+    const service2 = new ConversationService(resolvedOptions);
+    const providers2 = [
+      { provide: CONVERSATION_OPTIONS_TOKEN, useValue: resolvedOptions },
+      { provide: CONVERSATION_SERVICE_TOKEN, useValue: service2 },
+      ConversationService
+    ];
+    const existing = Reflect.getMetadata(MODULE_METADATA_KEY, ConversationModule) || {};
+    Reflect.defineMetadata(MODULE_METADATA_KEY, {
+      ...existing,
+      providers: [...existing.providers || [], ...providers2],
+      exports: [
+        ...existing.exports || [],
+        CONVERSATION_SERVICE_TOKEN,
+        ConversationService
+      ]
+    }, ConversationModule);
+    return ConversationModule;
+  }
+  static reset() {
+    Reflect.deleteMetadata(MODULE_METADATA_KEY, ConversationModule);
+  }
+}
+ConversationModule = __legacyDecorateClassTS([
+  Module({ providers: [] })
+], ConversationModule);
+// src/conversation/stores/redis-store.ts
+class RedisConversationStore {
+  client;
+  keyPrefix;
+  ttl;
+  constructor(config) {
+    this.client = config.client;
+    this.keyPrefix = config.keyPrefix ?? "conv:";
+    this.ttl = config.ttl ?? 86400;
+  }
+  async create(metadata = {}) {
+    const id = crypto.randomUUID();
+    const conversation = {
+      id,
+      messages: [],
+      metadata,
+      createdAt: new Date,
+      updatedAt: new Date
+    };
+    await this.save(conversation);
+    return conversation;
+  }
+  async get(id) {
+    const raw = await this.client.get(this.key(id));
+    if (!raw)
+      return null;
+    const parsed = JSON.parse(raw);
+    parsed.createdAt = new Date(parsed.createdAt);
+    parsed.updatedAt = new Date(parsed.updatedAt);
+    return parsed;
+  }
+  async appendMessage(id, message) {
+    const conv = await this.get(id);
+    if (!conv)
+      throw new Error(`Conversation "${id}" not found`);
+    conv.messages.push(message);
+    conv.updatedAt = new Date;
+    await this.save(conv);
+  }
+  async trim(id, maxMessages) {
+    const conv = await this.get(id);
+    if (!conv)
+      return;
+    if (conv.messages.length > maxMessages) {
+      conv.messages = conv.messages.slice(-maxMessages);
+      conv.updatedAt = new Date;
+      await this.save(conv);
+    }
+  }
+  async delete(id) {
+    const result = await this.client.del(this.key(id));
+    return Number(result) > 0;
+  }
+  async list() {
+    const keys = await this.client.keys(`${this.keyPrefix}*`);
+    return keys.map((k) => k.slice(this.keyPrefix.length));
+  }
+  key(id) {
+    return `${this.keyPrefix}${id}`;
+  }
+  async save(conversation) {
+    await this.client.set(this.key(conversation.id), JSON.stringify(conversation), "EX", this.ttl);
+  }
+}
+// src/conversation/stores/database-store.ts
+class DatabaseConversationStore {
+  db;
+  tableName;
+  initialized = false;
+  constructor(config) {
+    this.db = config.database;
+    this.tableName = config.tableName ?? "conversations";
+  }
+  async create(metadata = {}) {
+    await this.ensureTable();
+    const id = crypto.randomUUID();
+    const now = new Date().toISOString();
+    await this.db.execute(`INSERT INTO ${this.tableName} (id, messages, metadata, created_at, updated_at) VALUES (?, ?, ?, ?, ?)`, [id, "[]", JSON.stringify(metadata), now, now]);
+    return { id, messages: [], metadata, createdAt: new Date(now), updatedAt: new Date(now) };
+  }
+  async get(id) {
+    await this.ensureTable();
+    const rows = await this.db.query(`SELECT * FROM ${this.tableName} WHERE id = ?`, [id]);
+    if (!rows.length)
+      return null;
+    return this.rowToConversation(rows[0]);
+  }
+  async appendMessage(id, message) {
+    await this.ensureTable();
+    const conv = await this.get(id);
+    if (!conv)
+      throw new Error(`Conversation "${id}" not found`);
+    const messages = [...conv.messages, message];
+    const now = new Date().toISOString();
+    await this.db.execute(`UPDATE ${this.tableName} SET messages = ?, updated_at = ? WHERE id = ?`, [JSON.stringify(messages), now, id]);
+  }
+  async trim(id, maxMessages) {
+    await this.ensureTable();
+    const conv = await this.get(id);
+    if (!conv || conv.messages.length <= maxMessages)
+      return;
+    const trimmed = conv.messages.slice(-maxMessages);
+    const now = new Date().toISOString();
+    await this.db.execute(`UPDATE ${this.tableName} SET messages = ?, updated_at = ? WHERE id = ?`, [JSON.stringify(trimmed), now, id]);
+  }
+  async delete(id) {
+    await this.ensureTable();
+    await this.db.execute(`DELETE FROM ${this.tableName} WHERE id = ?`, [id]);
+    return true;
+  }
+  async list() {
+    await this.ensureTable();
+    const rows = await this.db.query(`SELECT id FROM ${this.tableName}`);
+    return rows.map((r) => r.id);
+  }
+  async ensureTable() {
+    if (this.initialized)
+      return;
+    await this.db.execute(`
+      CREATE TABLE IF NOT EXISTS ${this.tableName} (
+        id TEXT PRIMARY KEY,
+        messages TEXT NOT NULL DEFAULT '[]',
+        metadata TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      )
+    `);
+    this.initialized = true;
+  }
+  rowToConversation(row) {
+    return {
+      id: row["id"],
+      messages: JSON.parse(row["messages"]),
+      metadata: JSON.parse(row["metadata"]),
+      createdAt: new Date(row["created_at"]),
+      updatedAt: new Date(row["updated_at"])
+    };
+  }
+}
+// src/prompt/types.ts
+var PROMPT_SERVICE_TOKEN = Symbol("@dangao/bun-server:prompt:service");
+var PROMPT_OPTIONS_TOKEN = Symbol("@dangao/bun-server:prompt:options");
+function extractVariables(content) {
+  const regex = /\{\{(\w+)\}\}/g;
+  const vars = new Set;
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    vars.add(match[1]);
+  }
+  return Array.from(vars);
+}
+function renderTemplate(content, vars) {
+  return content.replace(/\{\{(\w+)\}\}/g, (_, key) => vars[key] ?? `{{${key}}}`);
+}
+// src/prompt/service.ts
+init_decorators();
+init_decorators();
+init_http_exception();
+class PromptService {
+  store;
+  constructor(options) {
+    this.store = options.store;
+  }
+  async get(id) {
+    const template = await this.store.get(id);
+    if (!template)
+      throw new HttpException(404, `Prompt template "${id}" not found`);
+    return template;
+  }
+  async getVersion(id, version) {
+    const template = await this.store.getVersion(id, version);
+    if (!template)
+      throw new HttpException(404, `Prompt template "${id}" version ${version} not found`);
+    return template;
+  }
+  async list() {
+    return this.store.list();
+  }
+  async create(input) {
+    return this.store.create(input);
+  }
+  async update(id, input) {
+    return this.store.update(id, input);
+  }
+  async delete(id) {
+    return this.store.delete(id);
+  }
+  async render(id, vars) {
+    const template = await this.get(id);
+    return renderTemplate(template.content, vars);
+  }
+  async renderVersion(id, version, vars) {
+    const template = await this.getVersion(id, version);
+    return renderTemplate(template.content, vars);
+  }
+}
+PromptService = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyDecorateParamTS(0, Inject(PROMPT_OPTIONS_TOKEN)),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof PromptModuleOptions === "undefined" ? Object : PromptModuleOptions
+  ])
+], PromptService);
+// src/prompt/prompt-module.ts
+init_module();
+
+// src/prompt/stores/memory-store.ts
+class InMemoryPromptStore {
+  templates = new Map;
+  history = new Map;
+  async get(id) {
+    return this.templates.get(id) ?? null;
+  }
+  async getVersion(id, version) {
+    return this.history.get(id)?.get(version) ?? null;
+  }
+  async list() {
+    return Array.from(this.templates.values());
+  }
+  async create(input) {
+    const id = input.id ?? crypto.randomUUID();
+    if (this.templates.has(id)) {
+      throw new Error(`Prompt template "${id}" already exists`);
+    }
+    const now = new Date;
+    const template = {
+      id,
+      name: input.name,
+      content: input.content,
+      version: 1,
+      variables: extractVariables(input.content),
+      description: input.description,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.templates.set(id, template);
+    this.saveVersion(template);
+    return { ...template };
+  }
+  async update(id, input) {
+    const existing = this.templates.get(id);
+    if (!existing)
+      throw new Error(`Prompt template "${id}" not found`);
+    const now = new Date;
+    const content = input.content ?? existing.content;
+    const updated = {
+      ...existing,
+      name: input.name ?? existing.name,
+      content,
+      description: input.description ?? existing.description,
+      version: existing.version + 1,
+      variables: extractVariables(content),
+      updatedAt: now
+    };
+    this.templates.set(id, updated);
+    this.saveVersion(updated);
+    return { ...updated };
+  }
+  async delete(id) {
+    const existed = this.templates.delete(id);
+    this.history.delete(id);
+    return existed;
+  }
+  saveVersion(template) {
+    if (!this.history.has(template.id)) {
+      this.history.set(template.id, new Map);
+    }
+    this.history.get(template.id).set(template.version, { ...template });
+  }
+}
+
+// src/prompt/prompt-module.ts
+class PromptModule {
+  static forRoot(options = {}) {
+    const resolvedOptions = {
+      ...options,
+      store: options.store ?? new InMemoryPromptStore
+    };
+    const service3 = new PromptService(resolvedOptions);
+    const providers2 = [
+      { provide: PROMPT_OPTIONS_TOKEN, useValue: resolvedOptions },
+      { provide: PROMPT_SERVICE_TOKEN, useValue: service3 },
+      PromptService
+    ];
+    const existing = Reflect.getMetadata(MODULE_METADATA_KEY, PromptModule) || {};
+    Reflect.defineMetadata(MODULE_METADATA_KEY, {
+      ...existing,
+      providers: [...existing.providers || [], ...providers2],
+      exports: [
+        ...existing.exports || [],
+        PROMPT_SERVICE_TOKEN,
+        PromptService
+      ]
+    }, PromptModule);
+    return PromptModule;
+  }
+  static reset() {
+    Reflect.deleteMetadata(MODULE_METADATA_KEY, PromptModule);
+  }
+}
+PromptModule = __legacyDecorateClassTS([
+  Module({ providers: [] })
+], PromptModule);
+// src/prompt/stores/file-store.ts
+class FilePromptStore {
+  promptsDir;
+  memory;
+  loaded = false;
+  constructor(config = {}) {
+    this.promptsDir = config.promptsDir ?? "./.prompts";
+    this.memory = new InMemoryPromptStore;
+  }
+  async get(id) {
+    await this.ensureLoaded();
+    return this.memory.get(id);
+  }
+  async getVersion(id, version) {
+    await this.ensureLoaded();
+    return this.memory.getVersion(id, version);
+  }
+  async list() {
+    await this.ensureLoaded();
+    return this.memory.list();
+  }
+  async create(input) {
+    await this.ensureLoaded();
+    const template = await this.memory.create(input);
+    await this.writeFile(template);
+    return template;
+  }
+  async update(id, input) {
+    await this.ensureLoaded();
+    const template = await this.memory.update(id, input);
+    await this.writeFile(template);
+    return template;
+  }
+  async delete(id) {
+    await this.ensureLoaded();
+    const deleted = await this.memory.delete(id);
+    if (deleted) {
+      try {
+        const path = `${this.promptsDir}/${id}.json`;
+        await Bun.file(path).exists() && Bun.write(path, "");
+      } catch {}
+    }
+    return deleted;
+  }
+  async ensureLoaded() {
+    if (this.loaded)
+      return;
+    this.loaded = true;
+    try {
+      const glob = new Bun.Glob("*.json");
+      const files = Array.from(glob.scanSync(this.promptsDir));
+      for (const file of files) {
+        try {
+          const content = await Bun.file(`${this.promptsDir}/${file}`).text();
+          if (!content.trim())
+            continue;
+          const data = JSON.parse(content);
+          const id = data.id ?? file.replace(/\.json$/, "");
+          await this.memory.create({ id, ...data }).catch(() => {});
+        } catch {}
+      }
+    } catch {}
+  }
+  async writeFile(template) {
+    try {
+      const content = JSON.stringify({
+        id: template.id,
+        name: template.name,
+        content: template.content,
+        description: template.description,
+        variables: extractVariables(template.content)
+      }, null, 2);
+      await Bun.write(`${this.promptsDir}/${template.id}.json`, content);
+    } catch {}
+  }
+}
+// src/embedding/types.ts
+var EMBEDDING_SERVICE_TOKEN = Symbol("@dangao/bun-server:embedding:service");
+var EMBEDDING_OPTIONS_TOKEN = Symbol("@dangao/bun-server:embedding:options");
+// src/embedding/service.ts
+init_decorators();
+init_decorators();
+class EmbeddingService2 {
+  provider;
+  batchSize;
+  constructor(options) {
+    this.provider = new options.provider.provider(options.provider.config);
+    this.batchSize = options.batchSize ?? 100;
+  }
+  async embed(text) {
+    return this.provider.embed(text);
+  }
+  async embedBatch(texts) {
+    const results = [];
+    for (let i = 0;i < texts.length; i += this.batchSize) {
+      const batch = texts.slice(i, i + this.batchSize);
+      const embeddings = await this.provider.embedBatch(batch);
+      results.push(...embeddings);
+    }
+    return results;
+  }
+  get dimensions() {
+    return this.provider.dimensions;
+  }
+  get providerName() {
+    return this.provider.name;
+  }
+}
+EmbeddingService2 = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyDecorateParamTS(0, Inject(EMBEDDING_OPTIONS_TOKEN)),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof EmbeddingModuleOptions === "undefined" ? Object : EmbeddingModuleOptions
+  ])
+], EmbeddingService2);
+// src/embedding/embedding-module.ts
+init_module();
+class EmbeddingModule {
+  static forRoot(options) {
+    const service4 = new EmbeddingService2(options);
+    const providers2 = [
+      { provide: EMBEDDING_OPTIONS_TOKEN, useValue: options },
+      { provide: EMBEDDING_SERVICE_TOKEN, useValue: service4 },
+      EmbeddingService2
+    ];
+    const existing = Reflect.getMetadata(MODULE_METADATA_KEY, EmbeddingModule) || {};
+    Reflect.defineMetadata(MODULE_METADATA_KEY, {
+      ...existing,
+      providers: [...existing.providers || [], ...providers2],
+      exports: [
+        ...existing.exports || [],
+        EMBEDDING_SERVICE_TOKEN,
+        EmbeddingService2
+      ]
+    }, EmbeddingModule);
+    return EmbeddingModule;
+  }
+  static reset() {
+    Reflect.deleteMetadata(MODULE_METADATA_KEY, EmbeddingModule);
+  }
+}
+EmbeddingModule = __legacyDecorateClassTS([
+  Module({ providers: [] })
+], EmbeddingModule);
+// src/embedding/providers/openai-embedding-provider.ts
+class OpenAIEmbeddingProvider {
+  name = "openai";
+  dimensions;
+  apiKey;
+  model;
+  baseUrl;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.model = config.model ?? "text-embedding-3-small";
+    this.baseUrl = (config.baseUrl ?? "https://api.openai.com/v1").replace(/\/$/, "");
+    this.dimensions = this.model.includes("large") ? 3072 : 1536;
+  }
+  async embed(text) {
+    const results = await this.embedBatch([text]);
+    return results[0];
+  }
+  async embedBatch(texts) {
+    const res = await fetch(`${this.baseUrl}/embeddings`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify({ input: texts, model: this.model })
+    });
+    if (res.status === 429)
+      throw new AiRateLimitError("openai-embedding");
+    if (!res.ok)
+      throw new AiProviderError(await res.text(), "openai-embedding", res.status);
+    const data = await res.json();
+    return data.data.map((d) => d.embedding);
+  }
+}
+// src/embedding/providers/ollama-embedding-provider.ts
+class OllamaEmbeddingProvider {
+  name = "ollama";
+  dimensions;
+  baseUrl;
+  model;
+  constructor(config = {}) {
+    this.baseUrl = (config.baseUrl ?? "http://localhost:11434").replace(/\/$/, "");
+    this.model = config.model ?? "nomic-embed-text";
+    this.dimensions = config.dimensions ?? 768;
+  }
+  async embed(text) {
+    const res = await fetch(`${this.baseUrl}/api/embed`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ model: this.model, input: text })
+    });
+    if (!res.ok)
+      throw new AiProviderError(await res.text(), "ollama-embedding", res.status);
+    const data = await res.json();
+    return data.embeddings[0];
+  }
+  async embedBatch(texts) {
+    return Promise.all(texts.map((t) => this.embed(t)));
+  }
+}
+// src/vector-store/types.ts
+var VECTOR_STORE_TOKEN = Symbol("@dangao/bun-server:vector-store:store");
+var VECTOR_STORE_OPTIONS_TOKEN = Symbol("@dangao/bun-server:vector-store:options");
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length)
+    return 0;
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0;i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  return denom === 0 ? 0 : dot / denom;
+}
+// src/vector-store/vector-store-module.ts
+init_module();
+
+// src/vector-store/stores/memory-store.ts
+class MemoryVectorStore {
+  documents = new Map;
+  async upsert(document) {
+    this.documents.set(this.key(document.id, document.collection), document);
+  }
+  async upsertBatch(documents) {
+    for (const doc of documents) {
+      this.documents.set(this.key(doc.id, doc.collection), doc);
+    }
+  }
+  async get(id, collection) {
+    return this.documents.get(this.key(id, collection)) ?? null;
+  }
+  async search(query, options = {}) {
+    const { topK = 5, minScore = 0, collection, filter: filter2 } = options;
+    const results = [];
+    for (const doc of this.documents.values()) {
+      if (collection && doc.collection !== collection)
+        continue;
+      if (filter2 && !filter2(doc))
+        continue;
+      const score = cosineSimilarity(query, doc.vector);
+      if (score >= minScore) {
+        results.push({ document: doc, score });
+      }
+    }
+    return results.sort((a, b) => b.score - a.score).slice(0, topK);
+  }
+  async delete(id, collection) {
+    return this.documents.delete(this.key(id, collection));
+  }
+  async deleteCollection(collection) {
+    for (const [key, doc] of this.documents.entries()) {
+      if (doc.collection === collection) {
+        this.documents.delete(key);
+      }
+    }
+  }
+  async count(collection) {
+    if (!collection)
+      return this.documents.size;
+    let count = 0;
+    for (const doc of this.documents.values()) {
+      if (doc.collection === collection)
+        count++;
+    }
+    return count;
+  }
+  key(id, collection) {
+    return collection ? `${collection}:${id}` : id;
+  }
+}
+
+// src/vector-store/vector-store-module.ts
+class VectorStoreModule {
+  static forRoot(options = {}) {
+    const store = options.store ?? new MemoryVectorStore;
+    const providers2 = [
+      { provide: VECTOR_STORE_OPTIONS_TOKEN, useValue: options },
+      { provide: VECTOR_STORE_TOKEN, useValue: store }
+    ];
+    const existing = Reflect.getMetadata(MODULE_METADATA_KEY, VectorStoreModule) || {};
+    Reflect.defineMetadata(MODULE_METADATA_KEY, {
+      ...existing,
+      providers: [...existing.providers || [], ...providers2],
+      exports: [
+        ...existing.exports || [],
+        VECTOR_STORE_TOKEN
+      ]
+    }, VectorStoreModule);
+    return VectorStoreModule;
+  }
+  static reset() {
+    Reflect.deleteMetadata(MODULE_METADATA_KEY, VectorStoreModule);
+  }
+}
+VectorStoreModule = __legacyDecorateClassTS([
+  Module({ providers: [] })
+], VectorStoreModule);
+// src/vector-store/stores/pinecone-store.ts
+class PineconeVectorStore {
+  apiKey;
+  host;
+  namespace;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.host = config.host.replace(/\/$/, "");
+    this.namespace = config.namespace ?? "";
+  }
+  async upsert(document) {
+    await this.upsertBatch([document]);
+  }
+  async upsertBatch(documents) {
+    const vectors = documents.map((d) => ({
+      id: d.id,
+      values: d.vector,
+      metadata: { content: d.content, collection: d.collection ?? "", ...d.metadata }
+    }));
+    await this.request("/vectors/upsert", "POST", { vectors, namespace: this.namespace });
+  }
+  async get(id) {
+    const res = await this.request(`/vectors/fetch?ids=${encodeURIComponent(id)}&namespace=${this.namespace}`, "GET");
+    const vector = res?.["vectors"]?.[id];
+    if (!vector)
+      return null;
+    const metadata = vector["metadata"] ?? {};
+    return {
+      id,
+      vector: vector["values"],
+      content: metadata["content"] ?? "",
+      collection: metadata["collection"] || undefined,
+      metadata
+    };
+  }
+  async search(query, options = {}) {
+    const { topK = 5, collection } = options;
+    const filter2 = collection ? { collection: { $eq: collection } } : undefined;
+    const res = await this.request("/query", "POST", {
+      vector: query,
+      topK,
+      includeMetadata: true,
+      namespace: this.namespace,
+      filter: filter2
+    });
+    return (res?.["matches"] ?? []).map((match) => {
+      const metadata = match["metadata"] ?? {};
+      return {
+        document: {
+          id: match["id"],
+          vector: [],
+          content: metadata["content"] ?? "",
+          collection: metadata["collection"] || undefined,
+          metadata
+        },
+        score: match["score"]
+      };
+    });
+  }
+  async delete(id) {
+    await this.request("/vectors/delete", "POST", { ids: [id], namespace: this.namespace });
+    return true;
+  }
+  async deleteCollection(collection) {
+    await this.request("/vectors/delete", "POST", {
+      deleteAll: false,
+      namespace: this.namespace,
+      filter: { collection: { $eq: collection } }
+    });
+  }
+  async count() {
+    const res = await this.request("/describe_index_stats", "POST", {});
+    const ns = res?.["namespaces"]?.[this.namespace];
+    return ns?.vectorCount ?? 0;
+  }
+  async request(path, method, body) {
+    const res = await fetch(`${this.host}${path}`, {
+      method,
+      headers: {
+        "Api-Key": this.apiKey,
+        "Content-Type": "application/json"
+      },
+      body: body !== undefined ? JSON.stringify(body) : undefined
+    });
+    if (!res.ok)
+      return null;
+    return res.json();
+  }
+}
+// src/vector-store/stores/qdrant-store.ts
+class QdrantVectorStore {
+  url;
+  collectionName;
+  apiKey;
+  constructor(config) {
+    this.url = (config.url ?? "http://localhost:6333").replace(/\/$/, "");
+    this.collectionName = config.collectionName;
+    this.apiKey = config.apiKey;
+  }
+  async upsert(document) {
+    await this.upsertBatch([document]);
+  }
+  async upsertBatch(documents) {
+    const points = documents.map((d, idx) => ({
+      id: this.toNumericId(d.id) ?? idx,
+      vector: d.vector,
+      payload: {
+        original_id: d.id,
+        content: d.content,
+        collection: d.collection ?? "",
+        ...d.metadata ?? {}
+      }
+    }));
+    await this.request(`/collections/${this.collectionName}/points`, "PUT", { points });
+  }
+  async get(id) {
+    const numId = this.toNumericId(id);
+    if (!numId)
+      return null;
+    const res = await this.request(`/collections/${this.collectionName}/points/${numId}`, "GET");
+    const point = res?.["result"];
+    if (!point)
+      return null;
+    const payload = point["payload"] ?? {};
+    return {
+      id: payload["original_id"] ?? id,
+      vector: point["vector"] ?? [],
+      content: payload["content"] ?? "",
+      collection: payload["collection"] || undefined,
+      metadata: payload
+    };
+  }
+  async search(query, options = {}) {
+    const { topK = 5, minScore = 0, collection } = options;
+    const body = {
+      vector: query,
+      limit: topK,
+      with_payload: true,
+      score_threshold: minScore
+    };
+    if (collection) {
+      body["filter"] = { must: [{ key: "collection", match: { value: collection } }] };
+    }
+    const res = await this.request(`/collections/${this.collectionName}/points/search`, "POST", body);
+    return (res?.["result"] ?? []).map((hit) => {
+      const payload = hit["payload"] ?? {};
+      return {
+        document: {
+          id: payload["original_id"] ?? String(hit["id"]),
+          vector: [],
+          content: payload["content"] ?? "",
+          collection: payload["collection"] || undefined,
+          metadata: payload
+        },
+        score: hit["score"]
+      };
+    });
+  }
+  async delete(id) {
+    const numId = this.toNumericId(id);
+    if (!numId)
+      return false;
+    await this.request(`/collections/${this.collectionName}/points/delete`, "POST", { points: [numId] });
+    return true;
+  }
+  async deleteCollection(collection) {
+    await this.request(`/collections/${this.collectionName}/points/delete`, "POST", { filter: { must: [{ key: "collection", match: { value: collection } }] } });
+  }
+  async count() {
+    const res = await this.request(`/collections/${this.collectionName}/points/count`, "POST", {});
+    return res?.["result"]?.count ?? 0;
+  }
+  toNumericId(id) {
+    const n = parseInt(id, 10);
+    return isNaN(n) ? null : n;
+  }
+  async request(path, method, body) {
+    const headers = { "Content-Type": "application/json" };
+    if (this.apiKey)
+      headers["api-key"] = this.apiKey;
+    const res = await fetch(`${this.url}${path}`, {
+      method,
+      headers,
+      body: body !== undefined ? JSON.stringify(body) : undefined
+    });
+    if (!res.ok)
+      return null;
+    return res.json();
+  }
+}
+// src/rag/types.ts
+var RAG_SERVICE_TOKEN = Symbol("@dangao/bun-server:rag:service");
+var RAG_OPTIONS_TOKEN = Symbol("@dangao/bun-server:rag:options");
+// src/rag/service.ts
+init_decorators();
+init_decorators();
+
+// src/rag/chunkers/text-chunker.ts
+class TextChunker {
+  chunkSize;
+  chunkOverlap;
+  constructor(chunkSize = 512, chunkOverlap = 50) {
+    this.chunkSize = chunkSize;
+    this.chunkOverlap = chunkOverlap;
+  }
+  chunk(text) {
+    const chunks = [];
+    const step = this.chunkSize - this.chunkOverlap;
+    for (let start = 0;start < text.length; start += step) {
+      const end = Math.min(start + this.chunkSize, text.length);
+      const content = text.slice(start, end).trim();
+      if (content.length > 0) {
+        chunks.push({ content });
+      }
+      if (end >= text.length)
+        break;
+    }
+    return chunks;
+  }
+}
+
+// src/rag/chunkers/markdown-chunker.ts
+class MarkdownChunker {
+  maxChunkSize;
+  constructor(maxChunkSize = 1024) {
+    this.maxChunkSize = maxChunkSize;
+  }
+  chunk(text) {
+    const chunks = [];
+    const sections = text.split(/(?=^#{1,3} )/m).filter((s) => s.trim());
+    for (const section of sections) {
+      if (section.length <= this.maxChunkSize) {
+        chunks.push({ content: section.trim() });
+      } else {
+        const paragraphs = section.split(/\n\n+/).filter((p) => p.trim());
+        let current = "";
+        for (const para of paragraphs) {
+          if ((current + `
+
+` + para).length > this.maxChunkSize && current) {
+            chunks.push({ content: current.trim() });
+            current = para;
+          } else {
+            current = current ? current + `
+
+` + para : para;
+          }
+        }
+        if (current.trim())
+          chunks.push({ content: current.trim() });
+      }
+    }
+    return chunks.length > 0 ? chunks : [{ content: text.trim() }];
+  }
+}
+
+// src/rag/service.ts
+class RagService {
+  options;
+  embeddingService;
+  vectorStore;
+  textChunker;
+  markdownChunker;
+  constructor(options, embeddingService, vectorStore) {
+    this.options = options;
+    this.embeddingService = embeddingService;
+    this.vectorStore = vectorStore;
+    this.textChunker = new TextChunker(options.chunkSize, options.chunkOverlap);
+    this.markdownChunker = new MarkdownChunker(options.chunkSize);
+  }
+  async ingest(source, collection) {
+    const targetCollection = collection ?? this.options.collection ?? "rag";
+    const text = await this.loadText(source);
+    if (!text.trim())
+      return 0;
+    const isMarkdown = source.type === "file" && (source.path.endsWith(".md") || source.path.endsWith(".mdx"));
+    const chunker = isMarkdown ? this.markdownChunker : this.textChunker;
+    const chunks = chunker.chunk(text);
+    const vectors = await this.embeddingService.embedBatch(chunks.map((c) => c.content));
+    for (let i = 0;i < chunks.length; i++) {
+      const chunk = chunks[i];
+      const vector = vectors[i];
+      await this.vectorStore.upsert({
+        id: crypto.randomUUID(),
+        vector,
+        content: chunk.content,
+        collection: targetCollection,
+        metadata: {
+          ...chunk.metadata ?? {},
+          ...source.metadata ?? {},
+          sourceType: source.type,
+          ...source.type === "file" ? { sourcePath: source.path } : {},
+          ...source.type === "url" ? { sourceUrl: source.url } : {}
+        }
+      });
+    }
+    return chunks.length;
+  }
+  async retrieve(query, collection) {
+    const targetCollection = collection ?? this.options.collection ?? "rag";
+    const queryVector = await this.embeddingService.embed(query);
+    const results = await this.vectorStore.search(queryVector, {
+      topK: this.options.topK ?? 5,
+      minScore: this.options.minScore ?? 0.5,
+      collection: targetCollection
+    });
+    const chunks = results.map((r) => ({
+      content: r.document.content,
+      score: r.score,
+      metadata: r.document.metadata
+    }));
+    const formatted = chunks.length > 0 ? chunks.map((c, i) => `[${i + 1}] ${c.content}`).join(`
+
+`) : "";
+    return { chunks, formatted };
+  }
+  async buildContextPrompt(query, collection) {
+    const context2 = await this.retrieve(query, collection);
+    if (!context2.formatted)
+      return "";
+    return `Use the following context to answer the question:
+
+${context2.formatted}`;
+  }
+  async loadText(source) {
+    switch (source.type) {
+      case "text":
+        return source.content;
+      case "file": {
+        const file = Bun.file(source.path);
+        return file.text();
+      }
+      case "url": {
+        const res = await fetch(source.url);
+        if (!res.ok)
+          throw new Error(`Failed to fetch ${source.url}: ${res.status}`);
+        return res.text();
+      }
+    }
+  }
+}
+RagService = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyDecorateParamTS(0, Inject(RAG_OPTIONS_TOKEN)),
+  __legacyDecorateParamTS(1, Inject(EMBEDDING_SERVICE_TOKEN)),
+  __legacyDecorateParamTS(2, Inject(VECTOR_STORE_TOKEN)),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof RagModuleOptions === "undefined" ? Object : RagModuleOptions,
+    typeof EmbeddingService === "undefined" ? Object : EmbeddingService,
+    typeof VectorStore === "undefined" ? Object : VectorStore
+  ])
+], RagService);
+// src/rag/decorators.ts
+var RAG_METADATA_KEY = "@dangao/bun-server:rag:collection";
+function Rag(options = {}) {
+  return (target, propertyKey) => {
+    Reflect.defineMetadata(RAG_METADATA_KEY, options, target, propertyKey);
+  };
+}
+// src/rag/rag-module.ts
+init_module();
+class RagModule {
+  static forRoot(options = {}) {
+    const resolvedOptions = {
+      collection: "rag",
+      chunkSize: 512,
+      chunkOverlap: 50,
+      topK: 5,
+      minScore: 0.5,
+      ...options
+    };
+    const providers2 = [
+      { provide: RAG_OPTIONS_TOKEN, useValue: resolvedOptions },
+      {
+        provide: RAG_SERVICE_TOKEN,
+        useFactory: (container) => {
+          const embeddingService = container.resolve(EMBEDDING_SERVICE_TOKEN);
+          const vectorStore = container.resolve(VECTOR_STORE_TOKEN);
+          return new RagService(resolvedOptions, embeddingService, vectorStore);
+        }
+      },
+      RagService
+    ];
+    const existing = Reflect.getMetadata(MODULE_METADATA_KEY, RagModule) || {};
+    Reflect.defineMetadata(MODULE_METADATA_KEY, {
+      ...existing,
+      imports: [
+        ...existing.imports || [],
+        EmbeddingModule,
+        VectorStoreModule
+      ],
+      providers: [...existing.providers || [], ...providers2],
+      exports: [
+        ...existing.exports || [],
+        RAG_SERVICE_TOKEN,
+        RagService
+      ]
+    }, RagModule);
+    return RagModule;
+  }
+  static reset() {
+    Reflect.deleteMetadata(MODULE_METADATA_KEY, RagModule);
+  }
+}
+RagModule = __legacyDecorateClassTS([
+  Module({
+    imports: [EmbeddingModule, VectorStoreModule],
+    providers: []
+  })
+], RagModule);
+// src/mcp/types.ts
+var MCP_SERVER_TOKEN = Symbol("@dangao/bun-server:mcp:server");
+var MCP_OPTIONS_TOKEN = Symbol("@dangao/bun-server:mcp:options");
+var MCP_TOOL_METADATA_KEY = "@dangao/bun-server:mcp:tool";
+var MCP_RESOURCE_METADATA_KEY = "@dangao/bun-server:mcp:resource";
+// src/mcp/decorators.ts
+function McpTool(definition) {
+  return (target, propertyKey) => {
+    Reflect.defineMetadata(MCP_TOOL_METADATA_KEY, definition, target, propertyKey);
+  };
+}
+function McpResource(definition) {
+  return (target, propertyKey) => {
+    Reflect.defineMetadata(MCP_RESOURCE_METADATA_KEY, definition, target, propertyKey);
+  };
+}
+function McpParam(name) {
+  return (target, propertyKey, parameterIndex) => {
+    const existing = Reflect.getMetadata("mcp:params", target, propertyKey) ?? [];
+    existing.push({ index: parameterIndex, name });
+    Reflect.defineMetadata("mcp:params", existing, target, propertyKey);
+  };
+}
+// src/mcp/registry.ts
+class McpRegistry {
+  tools = new Map;
+  resources = new Map;
+  scan(instance) {
+    const proto = Object.getPrototypeOf(instance);
+    const methodNames = Object.getOwnPropertyNames(proto).filter((key) => key !== "constructor");
+    for (const methodName of methodNames) {
+      const toolDef = Reflect.getMetadata(MCP_TOOL_METADATA_KEY, proto, methodName);
+      if (toolDef) {
+        const method = instance[methodName];
+        this.tools.set(toolDef.name, {
+          ...toolDef,
+          execute: (args) => method.call(instance, args)
+        });
+      }
+      const resourceDef = Reflect.getMetadata(MCP_RESOURCE_METADATA_KEY, proto, methodName);
+      if (resourceDef) {
+        const method = instance[methodName];
+        this.resources.set(resourceDef.uri, {
+          ...resourceDef,
+          read: (params) => method.call(instance, params)
+        });
+      }
+    }
+  }
+  getTools() {
+    return Array.from(this.tools.values());
+  }
+  getResources() {
+    return Array.from(this.resources.values());
+  }
+  getTool(name) {
+    return this.tools.get(name);
+  }
+  getResource(uri) {
+    return this.resources.get(uri);
+  }
+}
+// src/mcp/server.ts
+class McpServer {
+  registry;
+  serverInfo;
+  constructor(registry, serverInfo) {
+    this.registry = registry;
+    this.serverInfo = serverInfo;
+  }
+  async handle(request) {
+    try {
+      const result = await this.dispatch(request.method, request.params);
+      return { jsonrpc: "2.0", id: request.id ?? null, result };
+    } catch (err) {
+      return {
+        jsonrpc: "2.0",
+        id: request.id ?? null,
+        error: {
+          code: err instanceof McpError ? err.code : -32603,
+          message: err instanceof Error ? err.message : "Internal error"
+        }
+      };
+    }
+  }
+  async handleHttp(req) {
+    const body = await req.json();
+    const response = await this.handle(body);
+    return new Response(JSON.stringify(response), {
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  createSseResponse() {
+    const registry = this.registry;
+    const serverInfo = this.serverInfo;
+    const encoder = new TextEncoder;
+    const stream = new ReadableStream({
+      start(controller2) {
+        const initEvent = `event: endpoint
+data: ${JSON.stringify({
+          type: "endpoint",
+          method: "POST"
+        })}
+
+`;
+        controller2.enqueue(encoder.encode(initEvent));
+        const pingInterval = setInterval(() => {
+          try {
+            controller2.enqueue(encoder.encode(`: ping
+
+`));
+          } catch {
+            clearInterval(pingInterval);
+          }
+        }, 15000);
+      }
+    });
+    return new Response(stream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+        "X-MCP-Server": `${serverInfo.name}/${serverInfo.version}`
+      }
+    });
+  }
+  async dispatch(method, params) {
+    switch (method) {
+      case "initialize":
+        return {
+          protocolVersion: "2024-11-05",
+          capabilities: { tools: {}, resources: {} },
+          serverInfo: this.serverInfo
+        };
+      case "tools/list":
+        return {
+          tools: this.registry.getTools().map((t) => ({
+            name: t.name,
+            description: t.description,
+            inputSchema: t.inputSchema
+          }))
+        };
+      case "tools/call": {
+        const { name, arguments: args = {} } = params;
+        const tool = this.registry.getTool(name);
+        if (!tool)
+          throw new McpError(-32601, `Tool "${name}" not found`);
+        const result = await tool.execute(args);
+        return {
+          content: [
+            {
+              type: "text",
+              text: typeof result === "string" ? result : JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      }
+      case "resources/list":
+        return {
+          resources: this.registry.getResources().map((r) => ({
+            uri: r.uri,
+            name: r.name,
+            description: r.description,
+            mimeType: r.mimeType
+          }))
+        };
+      case "resources/read": {
+        const { uri } = params;
+        const resource = this.registry.getResource(uri);
+        if (!resource)
+          throw new McpError(-32601, `Resource "${uri}" not found`);
+        const content = await resource.read({});
+        return {
+          contents: [
+            {
+              uri,
+              mimeType: resource.mimeType ?? "application/json",
+              text: typeof content === "string" ? content : JSON.stringify(content)
+            }
+          ]
+        };
+      }
+      case "ping":
+        return {};
+      default:
+        throw new McpError(-32601, `Method "${method}" not found`);
+    }
+  }
+}
+
+class McpError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+}
+// src/mcp/mcp-module.ts
+init_module();
+class McpModule {
+  static forRoot(options) {
+    const registry = new McpRegistry;
+    const server = new McpServer(registry, options.serverInfo);
+    const resolvedOptions = {
+      transport: "sse",
+      path: "/mcp",
+      ...options
+    };
+    const providers2 = [
+      { provide: MCP_OPTIONS_TOKEN, useValue: resolvedOptions },
+      { provide: MCP_SERVER_TOKEN, useValue: server },
+      { provide: McpRegistry, useValue: registry }
+    ];
+    const existing = Reflect.getMetadata(MODULE_METADATA_KEY, McpModule) || {};
+    Reflect.defineMetadata(MODULE_METADATA_KEY, {
+      ...existing,
+      providers: [...existing.providers || [], ...providers2],
+      exports: [
+        ...existing.exports || [],
+        MCP_SERVER_TOKEN,
+        McpRegistry
+      ]
+    }, McpModule);
+    return McpModule;
+  }
+  static reset() {
+    Reflect.deleteMetadata(MODULE_METADATA_KEY, McpModule);
+  }
+}
+McpModule = __legacyDecorateClassTS([
+  Module({ providers: [] })
+], McpModule);
+// src/ai-guard/types.ts
+var AI_GUARD_SERVICE_TOKEN = Symbol("@dangao/bun-server:ai-guard:service");
+var AI_GUARD_OPTIONS_TOKEN = Symbol("@dangao/bun-server:ai-guard:options");
+var AI_GUARD_METADATA_KEY = "@dangao/bun-server:ai-guard:options";
+// src/ai-guard/decorators.ts
+function AiGuard(options = {}) {
+  return (target, propertyKey) => {
+    Reflect.defineMetadata(AI_GUARD_METADATA_KEY, options, target, propertyKey);
+  };
+}
+// src/ai-guard/service.ts
+init_decorators();
+init_decorators();
+
+// src/ai-guard/detectors/pii-detector.ts
+var PII_PATTERNS = [
+  {
+    type: "email",
+    regex: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g,
+    replacement: "[EMAIL]"
+  },
+  {
+    type: "phone",
+    regex: /(\+?1[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b/g,
+    replacement: "[PHONE]"
+  },
+  {
+    type: "ssn",
+    regex: /\b\d{3}-\d{2}-\d{4}\b/g,
+    replacement: "[SSN]"
+  },
+  {
+    type: "credit_card",
+    regex: /\b(?:\d[ -]?){13,16}\b/g,
+    replacement: "[CREDIT_CARD]"
+  },
+  {
+    type: "ip_address",
+    regex: /\b(?:\d{1,3}\.){3}\d{1,3}\b/g,
+    replacement: "[IP_ADDRESS]"
+  },
+  {
+    type: "url_with_credentials",
+    regex: /https?:\/\/[^:@\s]+:[^:@\s]+@[^\s]+/g,
+    replacement: "[URL_WITH_CREDENTIALS]"
+  }
+];
+
+class PiiDetector {
+  detect(text, redact = true) {
+    const foundTypes = new Set;
+    let sanitized = text;
+    for (const pattern of PII_PATTERNS) {
+      if (pattern.regex.test(text)) {
+        foundTypes.add(pattern.type);
+        if (redact) {
+          sanitized = sanitized.replace(pattern.regex, pattern.replacement);
+        }
+      }
+      pattern.regex.lastIndex = 0;
+    }
+    return {
+      detected: foundTypes.size > 0,
+      sanitized,
+      types: Array.from(foundTypes)
+    };
+  }
+}
+
+// src/ai-guard/detectors/content-moderator.ts
+class ContentModerator {
+  config;
+  constructor(config = {}) {
+    this.config = config;
+  }
+  async moderate(text) {
+    if (this.config.moderator) {
+      return this.config.moderator(text);
+    }
+    if (this.config.openaiApiKey) {
+      return this.moderateWithOpenAI(text);
+    }
+    return { flagged: false, categories: {}, scores: {} };
+  }
+  isBlocked(result) {
+    if (!result.flagged)
+      return false;
+    const blockCategories = this.config.blockCategories;
+    if (!blockCategories || blockCategories.length === 0)
+      return true;
+    return blockCategories.some((cat) => result.categories[cat]);
+  }
+  async moderateWithOpenAI(text) {
+    const res = await fetch("https://api.openai.com/v1/moderations", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.config.openaiApiKey}`
+      },
+      body: JSON.stringify({ input: text })
+    });
+    if (!res.ok) {
+      return { flagged: false, categories: {}, scores: {} };
+    }
+    const data = await res.json();
+    const result = data.results[0];
+    if (!result)
+      return { flagged: false, categories: {}, scores: {} };
+    return {
+      flagged: result.flagged,
+      categories: result.categories,
+      scores: result.category_scores
+    };
+  }
+}
+
+// src/ai-guard/detectors/injection-detector.ts
+var INJECTION_PATTERNS = [
+  { pattern: /ignore\s+(all\s+)?previous\s+instructions?/i, reason: "ignore_instructions", weight: 0.9 },
+  { pattern: /forget\s+(all\s+)?previous\s+instructions?/i, reason: "forget_instructions", weight: 0.9 },
+  { pattern: /you\s+are\s+now\s+(?:a\s+)?(?:different|new|another)/i, reason: "role_override", weight: 0.7 },
+  { pattern: /disregard\s+(?:your\s+)?(?:previous\s+)?(?:instructions?|guidelines?|rules?)/i, reason: "disregard_rules", weight: 0.8 },
+  { pattern: /system\s*:\s*(?:you|your|ignore)/i, reason: "fake_system_message", weight: 0.8 },
+  { pattern: /\[system\]/i, reason: "system_tag_injection", weight: 0.6 },
+  { pattern: /act\s+as\s+(?:an?\s+)?(?:unrestricted|unfiltered|jailbreak)/i, reason: "jailbreak_attempt", weight: 0.95 },
+  { pattern: /jailbreak|DAN\s+mode|developer\s+mode/i, reason: "jailbreak_keyword", weight: 0.85 },
+  { pattern: /print\s+your\s+(?:system\s+)?prompt|reveal\s+your\s+instructions?/i, reason: "prompt_extraction", weight: 0.7 }
+];
+
+class PromptInjectionDetector {
+  threshold;
+  constructor(sensitivity = "medium") {
+    this.threshold = sensitivity === "low" ? 0.85 : sensitivity === "medium" ? 0.7 : 0.55;
+  }
+  detect(text) {
+    let maxScore = 0;
+    let detectedReason;
+    for (const { pattern, reason, weight } of INJECTION_PATTERNS) {
+      if (pattern.test(text)) {
+        if (weight > maxScore) {
+          maxScore = weight;
+          detectedReason = reason;
+        }
+      }
+    }
+    return {
+      detected: maxScore >= this.threshold,
+      confidence: maxScore,
+      reason: detectedReason
+    };
+  }
+}
+
+// src/ai-guard/service.ts
+init_http_exception();
+class AiGuardService {
+  piiDetector;
+  contentModerator;
+  injectionDetector;
+  options;
+  constructor(options) {
+    this.options = options;
+    this.piiDetector = options.piiDetection ? new PiiDetector : null;
+    if (options.moderation) {
+      const modConfig = typeof options.moderation === "object" ? options.moderation : {};
+      this.contentModerator = new ContentModerator(modConfig);
+    } else {
+      this.contentModerator = null;
+    }
+    if (options.promptInjection) {
+      const injConfig = typeof options.promptInjection === "object" ? options.promptInjection : {};
+      this.injectionDetector = new PromptInjectionDetector(injConfig.sensitivity);
+    } else {
+      this.injectionDetector = null;
+    }
+  }
+  async check(text) {
+    let workingText = text;
+    const result = { allowed: true };
+    if (this.piiDetector) {
+      const redact = typeof this.options.piiDetection === "object" ? this.options.piiDetection.redact !== false : true;
+      const piiResult = this.piiDetector.detect(workingText, redact);
+      result.pii = piiResult;
+      if (redact && piiResult.detected) {
+        workingText = piiResult.sanitized;
+      }
+    }
+    if (this.injectionDetector) {
+      const injResult = this.injectionDetector.detect(workingText);
+      result.injection = injResult;
+      if (injResult.detected) {
+        result.allowed = false;
+      }
+    }
+    if (this.contentModerator && result.allowed) {
+      const modResult = await this.contentModerator.moderate(workingText);
+      result.moderation = modResult;
+      if (this.contentModerator.isBlocked(modResult)) {
+        result.allowed = false;
+      }
+    }
+    result.sanitizedInput = workingText;
+    return result;
+  }
+  async checkOrThrow(text) {
+    const result = await this.check(text);
+    if (!result.allowed) {
+      const reason = result.injection?.detected ? "Prompt injection detected" : result.moderation?.flagged ? "Content violates usage policies" : "Content not allowed";
+      throw new HttpException(400, reason);
+    }
+    return result.sanitizedInput ?? text;
+  }
+}
+AiGuardService = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyDecorateParamTS(0, Inject(AI_GUARD_OPTIONS_TOKEN)),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof AiGuardModuleOptions === "undefined" ? Object : AiGuardModuleOptions
+  ])
+], AiGuardService);
+// src/ai-guard/ai-guard-module.ts
+init_module();
+class AiGuardModule {
+  static forRoot(options = {}) {
+    const service6 = new AiGuardService(options);
+    const providers2 = [
+      { provide: AI_GUARD_OPTIONS_TOKEN, useValue: options },
+      { provide: AI_GUARD_SERVICE_TOKEN, useValue: service6 },
+      AiGuardService
+    ];
+    const existing = Reflect.getMetadata(MODULE_METADATA_KEY, AiGuardModule) || {};
+    Reflect.defineMetadata(MODULE_METADATA_KEY, {
+      ...existing,
+      providers: [...existing.providers || [], ...providers2],
+      exports: [
+        ...existing.exports || [],
+        AI_GUARD_SERVICE_TOKEN,
+        AiGuardService
+      ]
+    }, AiGuardModule);
+    return AiGuardModule;
+  }
+  static reset() {
+    Reflect.deleteMetadata(MODULE_METADATA_KEY, AiGuardModule);
+  }
+}
+AiGuardModule = __legacyDecorateClassTS([
+  Module({ providers: [] })
+], AiGuardModule);
 export {
   validateParameters,
   validateObjectSync,
   validateObject,
   scanInterceptorMetadata,
   requiresAuth,
+  renderTemplate,
   registerReflector,
   isValidateClass,
   isGlobalModule,
@@ -12941,6 +15648,8 @@ export {
   getColumnMetadata,
   getClassValidationMetadata,
   getAuthMetadata,
+  extractVariables,
+  extractConversationId,
   createUserKeyGenerator,
   createTokenKeyGenerator,
   createSwaggerUIMiddleware,
@@ -12960,17 +15669,21 @@ export {
   createCustomValidator,
   createCorsMiddleware,
   createClient,
+  cosineSimilarity,
   contextStore,
   checkRoles,
   applyDecorators,
   WeightedRoundRobinLoadBalancer,
   WebSocketGatewayRegistry,
   WebSocketGateway,
+  VectorStoreModule,
   ValidationError,
   ValidateNested,
   ValidateIf,
   ValidateClass,
   Validate,
+  VECTOR_STORE_TOKEN,
+  VECTOR_STORE_OPTIONS_TOKEN,
   UserInfoRequestInterceptor,
   UseMiddleware,
   UseGuards,
@@ -12982,6 +15695,9 @@ export {
   TransactionInterceptor,
   Tracer,
   TraceIdRequestInterceptor,
+  ToolRegistry,
+  ToolExecutor,
+  TextChunker,
   TestingModuleBuilder,
   TestingModule,
   TestHttpClient,
@@ -13021,38 +15737,57 @@ export {
   Repository,
   Reflector,
   RedisSessionStore,
+  RedisConversationStore,
   RedisCacheStore,
   RateLimiter,
   RateLimit,
   RandomLoadBalancer,
+  RagService,
+  RagModule,
+  Rag,
   ROLES_METADATA_KEY,
   REFLECTOR_TOKEN,
+  RAG_SERVICE_TOKEN,
+  RAG_OPTIONS_TOKEN,
+  RAG_METADATA_KEY,
   QueueService,
   QueueModule,
   Queue,
   QueryMap,
   Query,
+  QdrantVectorStore,
   QUEUE_SERVICE_TOKEN,
   QUEUE_OPTIONS_TOKEN,
   Property,
   Propagation,
+  PromptService,
+  PromptModule,
+  PromptInjectionDetector,
   PrometheusFormatter,
   PrimaryKey,
+  PineconeVectorStore,
+  PiiDetector,
   PermissionInterceptor,
   Permission,
   PerformanceHarness,
   ParamBinder,
   Param,
   PUT,
+  PROMPT_SERVICE_TOKEN,
+  PROMPT_OPTIONS_TOKEN,
   POST,
   PERMISSION_METADATA_KEY,
   PATCH,
   OrmService,
   OptionalAuthGuard,
+  OpenAIProvider,
+  OpenAIEmbeddingProvider,
   OnOpen,
   OnMessage,
   OnEvent,
   OnClose,
+  OllamaProvider,
+  OllamaEmbeddingProvider,
   ORM_SERVICE_TOKEN,
   ON_EVENT_METADATA_KEY,
   OAuth2Service,
@@ -13072,15 +15807,28 @@ export {
   MiddlewarePipeline,
   MetricsModule,
   MetricsCollector,
+  MemoryVectorStore,
   MemoryTraceCollector,
   MemorySessionStore,
   MemoryQueueStore,
+  MemoryConversationStore,
   MemoryCacheStore,
+  McpTool,
+  McpServer,
+  McpResource,
+  McpRegistry,
+  McpParam,
+  McpModule,
   MaxLength,
   Max,
   Matches,
+  MarkdownChunker,
   METRICS_SERVICE_TOKEN,
   METRICS_OPTIONS_TOKEN,
+  MCP_TOOL_METADATA_KEY,
+  MCP_SERVER_TOKEN,
+  MCP_RESOURCE_METADATA_KEY,
+  MCP_OPTIONS_TOKEN,
   LoggerModule,
   LoggerExtension,
   LogLevel2 as LogLevel,
@@ -13133,7 +15881,9 @@ export {
   InterceptorRegistry,
   InterceptorChain,
   Injectable,
+  InjectConversation,
   Inject,
+  InMemoryPromptStore,
   INTERCEPTOR_REGISTRY_TOKEN,
   HttpException,
   HealthModule,
@@ -13142,12 +15892,14 @@ export {
   HEALTH_OPTIONS_TOKEN,
   HEALTH_INDICATORS_TOKEN,
   GuardRegistry,
+  GoogleProvider,
   Global,
   GUARD_REGISTRY_TOKEN,
   GUARDS_METADATA_KEY,
   GLOBAL_MODULE_METADATA_KEY,
   GET,
   ForbiddenException,
+  FilePromptStore,
   ExecutionContextImpl,
   ExceptionFilterRegistry,
   EventModule,
@@ -13157,16 +15909,21 @@ export {
   Equals,
   Entity,
   EnableCacheProxy,
+  EmbeddingService2 as EmbeddingService,
+  EmbeddingModule,
   EVENT_OPTIONS_TOKEN,
   EVENT_LISTENER_SCANNER_TOKEN,
   EVENT_LISTENER_CLASS_METADATA_KEY,
   EVENT_EMITTER_TOKEN,
+  EMBEDDING_SERVICE_TOKEN,
+  EMBEDDING_OPTIONS_TOKEN,
   DrizzleBaseRepository,
   DebugModule,
   DatabaseService2 as DatabaseService,
   DatabaseModule,
   DatabaseHealthIndicator,
   DatabaseExtension,
+  DatabaseConversationStore,
   DatabaseConnectionManager,
   DashboardService,
   DashboardModule,
@@ -13177,11 +15934,14 @@ export {
   DATABASE_OPTIONS_TOKEN,
   DASHBOARD_OPTIONS_TOKEN,
   Cron,
+  ConversationService,
+  ConversationModule,
   ControllerRegistry,
   Controller,
   ContextService,
   Context2 as ContextParam,
   Context,
+  ContentModerator,
   Contains,
   Container,
   ConsoleTraceCollector,
@@ -13207,6 +15967,8 @@ export {
   CacheEvictInterceptor,
   CacheEvict,
   Cache,
+  CONVERSATION_SERVICE_TOKEN,
+  CONVERSATION_OPTIONS_TOKEN,
   CONTEXT_SERVICE_TOKEN,
   CONFIG_SERVICE_TOKEN,
   CONFIG_CENTER_TOKEN,
@@ -13236,5 +15998,25 @@ export {
   ApiResponse,
   ApiParam,
   ApiOperation,
-  ApiBody
+  ApiBody,
+  AnthropicProvider,
+  AiTool,
+  AiTimeoutError,
+  AiService,
+  AiRateLimitError,
+  AiProviderError,
+  AiNoProviderError,
+  AiModule,
+  AiGuardService,
+  AiGuardModule,
+  AiGuard,
+  AiContextLengthError,
+  AiAllProvidersFailed,
+  AI_TOOL_REGISTRY_TOKEN,
+  AI_TOOL_METADATA_KEY,
+  AI_SERVICE_TOKEN,
+  AI_MODULE_OPTIONS_TOKEN,
+  AI_GUARD_SERVICE_TOKEN,
+  AI_GUARD_OPTIONS_TOKEN,
+  AI_GUARD_METADATA_KEY
 };