@dangao/bun-server 1.12.1 → 2.0.1

package/src/ai/ai-module.ts

@@ -0,0 +1,62 @@
+import { Module, MODULE_METADATA_KEY } from '../di/module';
+import type { ModuleProvider } from '../di/module';
+import { AiService } from './service';
+import {
+  AI_SERVICE_TOKEN,
+  AI_MODULE_OPTIONS_TOKEN,
+  AI_TOOL_REGISTRY_TOKEN,
+  type AiModuleOptions,
+} from './types';
+import { ToolRegistry } from './tools/tool-registry';
+
+@Module({ providers: [] })
+export class AiModule {
+  /**
+   * Configure the AI module with one or more LLM providers.
+   *
+   * @example
+   * ```typescript
+   * AiModule.forRoot({
+   *   providers: [
+   *     { name: 'openai', provider: OpenAIProvider, config: { apiKey: '...' }, default: true },
+   *     { name: 'ollama', provider: OllamaProvider, config: {} },
+   *   ],
+   *   fallback: true,
+   *   timeout: 30000,
+   * });
+   * ```
+   */
+  public static forRoot(options: AiModuleOptions): typeof AiModule {
+    const toolRegistry = new ToolRegistry();
+    const aiService = new AiService(options);
+    aiService.setToolRegistry(toolRegistry);
+
+    const providers: ModuleProvider[] = [
+      { 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 || []), ...providers],
+      exports: [
+        ...(existing.exports || []),
+        AI_SERVICE_TOKEN,
+        AI_TOOL_REGISTRY_TOKEN,
+        AiService,
+      ],
+    }, AiModule);
+
+    return AiModule;
+  }
+
+  /**
+   * Reset module state (for testing)
+   */
+  public static reset(): void {
+    Reflect.deleteMetadata(MODULE_METADATA_KEY, AiModule);
+  }
+}

package/src/ai/decorators.ts

@@ -0,0 +1,30 @@
+import type { AiToolDefinition } from './types';
+import { AI_TOOL_METADATA_KEY } from './types';
+
+/**
+ * Mark a service method as an AI tool available for Tool Calling.
+ *
+ * @example
+ * ```typescript
+ * \@Injectable()
+ * class CalculatorService {
+ *   \@AiTool({
+ *     name: 'calculate',
+ *     description: 'Evaluate a mathematical expression',
+ *     parameters: {
+ *       type: 'object',
+ *       properties: { expression: { type: 'string' } },
+ *       required: ['expression'],
+ *     },
+ *   })
+ *   public calculate({ expression }: { expression: string }): string {
+ *     return String(eval(expression));
+ *   }
+ * }
+ * ```
+ */
+export function AiTool(definition: AiToolDefinition): MethodDecorator {
+  return (target, propertyKey) => {
+    Reflect.defineMetadata(AI_TOOL_METADATA_KEY, definition, target, propertyKey);
+  };
+}

package/src/ai/errors.ts

@@ -0,0 +1,71 @@
+import { HttpException } from '../error/http-exception';
+
+/**
+ * Base AI provider error
+ */
+export class AiProviderError extends HttpException {
+  public constructor(
+    message: string,
+    public readonly provider: string,
+    statusCode = 502,
+  ) {
+    super(statusCode, `[${provider}] ${message}`);
+  }
+}
+
+/**
+ * LLM rate limit exceeded
+ */
+export class AiRateLimitError extends AiProviderError {
+  public constructor(provider: string, retryAfterMs?: number) {
+    super(
+      retryAfterMs
+        ? `Rate limit exceeded. Retry after ${retryAfterMs}ms`
+        : 'Rate limit exceeded',
+      provider,
+      429,
+    );
+  }
+}
+
+/**
+ * Input exceeds model context window
+ */
+export class AiContextLengthError extends AiProviderError {
+  public constructor(provider: string, maxTokens?: number) {
+    super(
+      maxTokens
+        ? `Context length exceeded (max ${maxTokens} tokens)`
+        : 'Context length exceeded',
+      provider,
+      413,
+    );
+  }
+}
+
+/**
+ * LLM request timed out
+ */
+export class AiTimeoutError extends AiProviderError {
+  public constructor(provider: string, timeoutMs: number) {
+    super(`Request timed out after ${timeoutMs}ms`, provider, 504);
+  }
+}
+
+/**
+ * No AI providers configured
+ */
+export class AiNoProviderError extends HttpException {
+  public constructor() {
+    super(500, 'No AI providers configured. Call AiModule.forRoot() first.');
+  }
+}
+
+/**
+ * All providers in fallback chain failed
+ */
+export class AiAllProvidersFailed extends HttpException {
+  public constructor(errors: string[]) {
+    super(502, `All AI providers failed: ${errors.join('; ')}`);
+  }
+}

package/src/ai/index.ts

@@ -0,0 +1,11 @@
+export * from './types';
+export * from './errors';
+export * from './decorators';
+export * from './service';
+export * from './ai-module';
+export * from './tools/tool-registry';
+export * from './tools/tool-executor';
+export * from './providers/openai-provider';
+export * from './providers/anthropic-provider';
+export * from './providers/ollama-provider';
+export * from './providers/google-provider';

package/src/ai/providers/anthropic-provider.ts

@@ -0,0 +1,190 @@
+import type { LlmProvider, AiRequest, AiResponse, AiMessage } from '../types';
+import { AiProviderError, AiRateLimitError, AiContextLengthError } from '../errors';
+
+export interface AnthropicProviderConfig {
+  apiKey: string;
+  /** Default: https://api.anthropic.com */
+  baseUrl?: string;
+  /** Default: claude-3-7-sonnet-20250219 */
+  defaultModel?: string;
+  /** API version header */
+  anthropicVersion?: string;
+}
+
+export class AnthropicProvider implements LlmProvider {
+  public readonly name = 'anthropic';
+  private readonly apiKey: string;
+  private readonly baseUrl: string;
+  private readonly defaultModel: string;
+  private readonly anthropicVersion: string;
+
+  public constructor(config: AnthropicProviderConfig) {
+    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';
+  }
+
+  public async complete(request: AiRequest): Promise<AiResponse> {
+    const model = request.model ?? this.defaultModel;
+
+    // Separate system message from user/assistant messages
+    const systemMessages = request.messages.filter((m) => m.role === 'system');
+    const chatMessages = request.messages.filter((m) => m.role !== 'system');
+
+    const body: Record<string, unknown> = {
+      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('\n');
+    }
+
+    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'] as { input_tokens: number; output_tokens: number }) ?? { input_tokens: 0, output_tokens: 0 };
+
+    let content = '';
+    const toolCalls: AiResponse['toolCalls'] = [];
+    const contentBlocks = response['content'] as Array<Record<string, unknown>>;
+
+    for (const block of contentBlocks) {
+      if (block['type'] === 'text') content += block['text'] as string;
+      else if (block['type'] === 'tool_use') {
+        toolCalls.push({
+          id: block['id'] as string,
+          name: block['name'] as string,
+          arguments: block['input'] as Record<string, unknown>,
+        });
+      }
+    }
+
+    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',
+    };
+  }
+
+  public stream(request: AiRequest): ReadableStream<Uint8Array> {
+    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: Record<string, unknown> = {
+      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('\n');
+    }
+
+    const apiKey = this.apiKey;
+    const baseUrl = this.baseUrl;
+    const anthropicVersion = this.anthropicVersion;
+    const encoder = new TextEncoder();
+
+    return new ReadableStream<Uint8Array>({
+      async start(controller) {
+        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) {
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify({ error: await res.text(), done: true })}\n\n`));
+            controller.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('\n');
+            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') {
+                    controller.enqueue(encoder.encode(
+                      `data: ${JSON.stringify({ content: parsed.delta?.text ?? '', done: false })}\n\n`,
+                    ));
+                  } else if (parsed.type === 'message_stop') {
+                    controller.enqueue(encoder.encode(`data: ${JSON.stringify({ done: true })}\n\n`));
+                  }
+                } catch {
+                  // skip
+                }
+              }
+            }
+          }
+        } catch (err) {
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify({ error: String(err), done: true })}\n\n`));
+        } finally {
+          controller.close();
+        }
+      },
+    });
+  }
+
+  public countTokens(messages: AiMessage[]): number {
+    return Math.ceil(messages.reduce((sum, m) => sum + m.content.length, 0) / 4);
+  }
+
+  private async post(path: string, body: Record<string, unknown>): Promise<Record<string, unknown>> {
+    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() as Promise<Record<string, unknown>>;
+  }
+}

package/src/ai/providers/google-provider.ts

@@ -0,0 +1,179 @@
+import type { LlmProvider, AiRequest, AiResponse, AiMessage } from '../types';
+import { AiProviderError, AiRateLimitError } from '../errors';
+
+export interface GoogleProviderConfig {
+  apiKey: string;
+  /** Default: gemini-2.0-flash */
+  defaultModel?: string;
+  /** Default: https://generativelanguage.googleapis.com/v1beta */
+  baseUrl?: string;
+}
+
+export class GoogleProvider implements LlmProvider {
+  public readonly name = 'google';
+  private readonly apiKey: string;
+  private readonly defaultModel: string;
+  private readonly baseUrl: string;
+
+  public constructor(config: GoogleProviderConfig) {
+    this.apiKey = config.apiKey;
+    this.defaultModel = config.defaultModel ?? 'gemini-2.0-flash';
+    this.baseUrl = (config.baseUrl ?? 'https://generativelanguage.googleapis.com/v1beta').replace(/\/$/, '');
+  }
+
+  public async complete(request: AiRequest): Promise<AiResponse> {
+    const model = request.model ?? this.defaultModel;
+    const { contents, systemInstruction } = this.toGeminiMessages(request.messages);
+
+    const body: Record<string, unknown> = {
+      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() as Record<string, unknown>;
+    const candidate = (data['candidates'] as Array<Record<string, unknown>>)?.[0];
+    const parts = (candidate?.['content'] as Record<string, unknown>)?.['parts'] as Array<Record<string, unknown>> ?? [];
+
+    let content = '';
+    const toolCalls: AiResponse['toolCalls'] = [];
+    for (const part of parts) {
+      if (part['text']) content += part['text'] as string;
+      else if (part['functionCall']) {
+        const fc = part['functionCall'] as Record<string, unknown>;
+        toolCalls.push({
+          id: `fc-${Date.now()}`,
+          name: fc['name'] as string,
+          arguments: fc['args'] as Record<string, unknown>,
+        });
+      }
+    }
+
+    const usageMeta = data['usageMetadata'] as Record<string, number> ?? {};
+    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',
+    };
+  }
+
+  public stream(request: AiRequest): ReadableStream<Uint8Array> {
+    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: Record<string, unknown> = {
+      contents,
+      generationConfig: { temperature: request.temperature, maxOutputTokens: request.maxTokens },
+    };
+    if (systemInstruction) body['system_instruction'] = { parts: [{ text: systemInstruction }] };
+
+    return new ReadableStream<Uint8Array>({
+      async start(controller) {
+        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) {
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify({ error: await res.text(), done: true })}\n\n`));
+            controller.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('\n');
+            buf = lines.pop() ?? '';
+
+            for (const line of lines) {
+              if (line.startsWith('data: ')) {
+                try {
+                  const parsed = JSON.parse(line.slice(6)) as Record<string, unknown>;
+                  const candidate = (parsed['candidates'] as Array<Record<string, unknown>>)?.[0];
+                  const parts = (candidate?.['content'] as Record<string, unknown>)?.['parts'] as Array<Record<string, unknown>> ?? [];
+                  const text = parts.map((p) => p['text'] ?? '').join('');
+                  controller.enqueue(encoder.encode(`data: ${JSON.stringify({ content: text, done: false })}\n\n`));
+                } catch {
+                  // skip
+                }
+              }
+            }
+          }
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify({ done: true })}\n\n`));
+        } catch (err) {
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify({ error: String(err), done: true })}\n\n`));
+        } finally {
+          controller.close();
+        }
+      },
+    });
+  }
+
+  public countTokens(messages: AiMessage[]): number {
+    return Math.ceil(messages.reduce((sum, m) => sum + m.content.length, 0) / 4);
+  }
+
+  private toGeminiMessages(messages: AiMessage[]): {
+    contents: unknown[];
+    systemInstruction?: string;
+  } {
+    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('\n') : undefined,
+    };
+  }
+}

package/src/ai/providers/ollama-provider.ts

@@ -0,0 +1,126 @@
+import type { LlmProvider, AiRequest, AiResponse, AiMessage } from '../types';
+import { AiProviderError } from '../errors';
+
+export interface OllamaProviderConfig {
+  /** Default: http://localhost:11434 */
+  baseUrl?: string;
+  /** Default model to use */
+  defaultModel?: string;
+}
+
+export class OllamaProvider implements LlmProvider {
+  public readonly name = 'ollama';
+  private readonly baseUrl: string;
+  private readonly defaultModel: string;
+
+  public constructor(config: OllamaProviderConfig = {}) {
+    this.baseUrl = (config.baseUrl ?? 'http://localhost:11434').replace(/\/$/, '');
+    this.defaultModel = config.defaultModel ?? 'llama3.2';
+  }
+
+  public async complete(request: AiRequest): Promise<AiResponse> {
+    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() as Record<string, unknown>;
+    const message = data['message'] as Record<string, unknown>;
+    const evalCount = (data['eval_count'] as number) ?? 0;
+    const promptEvalCount = (data['prompt_eval_count'] as number) ?? 0;
+
+    return {
+      content: (message['content'] as string) ?? '',
+      model,
+      provider: this.name,
+      usage: {
+        promptTokens: promptEvalCount,
+        completionTokens: evalCount,
+        totalTokens: promptEvalCount + evalCount,
+      },
+      finishReason: 'stop',
+    };
+  }
+
+  public stream(request: AiRequest): ReadableStream<Uint8Array> {
+    const model = request.model ?? this.defaultModel;
+    const baseUrl = this.baseUrl;
+    const encoder = new TextEncoder();
+
+    return new ReadableStream<Uint8Array>({
+      async start(controller) {
+        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) {
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify({ error: await res.text(), done: true })}\n\n`));
+            controller.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('\n');
+            buf = lines.pop() ?? '';
+
+            for (const line of lines) {
+              if (!line.trim()) continue;
+              try {
+                const parsed = JSON.parse(line) as Record<string, unknown>;
+                const msgContent = (parsed['message'] as Record<string, unknown>)?.['content'] as string ?? '';
+                const isDone = Boolean(parsed['done']);
+                controller.enqueue(encoder.encode(
+                  `data: ${JSON.stringify({ content: msgContent, done: isDone })}\n\n`,
+                ));
+              } catch {
+                // skip
+              }
+            }
+          }
+        } catch (err) {
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify({ error: String(err), done: true })}\n\n`));
+        } finally {
+          controller.close();
+        }
+      },
+    });
+  }
+
+  public countTokens(messages: AiMessage[]): number {
+    return Math.ceil(messages.reduce((sum, m) => sum + m.content.length, 0) / 4);
+  }
+}