zero-ai-cli 1.0.0

package/packages/core/src/providers/registry.ts

@@ -0,0 +1,687 @@
+/**
+ * ZERO LLM Provider System
+ * Unified interface for all LLM providers
+ *
+ * Sources:
+ * - gemini-cli: model routing, content generation
+ * - qwen-code: multi-provider support with presets
+ * - pi: provider abstraction layer
+ * - opencode: LLM routing
+ * - goose: provider types system
+ * - cline: extensive API support
+ */
+
+import type {
+  LLMProvider,
+  LLMClient,
+  ProviderConfig,
+  ProviderType,
+  ModelConfig,
+  Message,
+  ChatOptions,
+  ChatResponse,
+  StreamChunk,
+  MessageContent,
+  ToolDefinition,
+  TokenUsage,
+  StopReason,
+} from "../types.js";
+
+// ============================================================================
+// Provider Registry
+// ============================================================================
+
+export class ProviderRegistry {
+  private providers = new Map<string, LLMProvider>();
+
+  register(provider: LLMProvider): void {
+    this.providers.set(provider.id, provider);
+  }
+
+  get(id: string): LLMProvider | undefined {
+    return this.providers.get(id);
+  }
+
+  list(): LLMProvider[] {
+    return Array.from(this.providers.values());
+  }
+
+  getAllModels(): { provider: string; model: ModelConfig }[] {
+    const models: { provider: string; model: ModelConfig }[] = [];
+    for (const provider of this.providers.values()) {
+      for (const model of provider.models) {
+        models.push({ provider: provider.id, model });
+      }
+    }
+    return models;
+  }
+
+  createClient(providerId: string, config: ProviderConfig): LLMClient {
+    const provider = this.providers.get(providerId);
+    if (!provider) {
+      throw new Error(`Provider "${providerId}" not found. Available: ${Array.from(this.providers.keys()).join(", ")}`);
+    }
+    return provider.createClient(config);
+  }
+
+  /**
+   * Load all built-in providers
+   */
+  loadBuiltins(): void {
+    this.register(createOpenAIProvider());
+    this.register(createAnthropicProvider());
+    this.register(createGoogleProvider());
+    this.register(createOllamaProvider());
+    this.register(createCustomProvider());
+  }
+}
+
+// ============================================================================
+// OpenAI-Compatible Provider
+// ============================================================================
+
+function createOpenAIProvider(): LLMProvider {
+  return {
+    id: "openai",
+    name: "OpenAI",
+    type: "openai",
+    models: [
+      {
+        id: "gpt-4o",
+        name: "GPT-4o",
+        contextWindow: 128000,
+        maxOutputTokens: 16384,
+        supportsImages: true,
+        supportsToolUse: true,
+        supportsStreaming: true,
+      },
+      {
+        id: "gpt-4o-mini",
+        name: "GPT-4o Mini",
+        contextWindow: 128000,
+        maxOutputTokens: 16384,
+        supportsImages: true,
+        supportsToolUse: true,
+        supportsStreaming: true,
+      },
+      {
+        id: "o1",
+        name: "o1",
+        contextWindow: 200000,
+        maxOutputTokens: 100000,
+        supportsImages: true,
+        supportsToolUse: true,
+        supportsStreaming: false,
+      },
+      {
+        id: "o3-mini",
+        name: "o3-mini",
+        contextWindow: 200000,
+        maxOutputTokens: 100000,
+        supportsImages: false,
+        supportsToolUse: true,
+        supportsStreaming: false,
+      },
+    ],
+    createClient: (config) => new OpenAICompatibleClient(config, "https://api.openai.com/v1"),
+  };
+}
+
+// ============================================================================
+// Anthropic Provider
+// ============================================================================
+
+function createAnthropicProvider(): LLMProvider {
+  return {
+    id: "anthropic",
+    name: "Anthropic",
+    type: "anthropic",
+    models: [
+      {
+        id: "claude-sonnet-4-20250514",
+        name: "Claude Sonnet 4",
+        contextWindow: 200000,
+        maxOutputTokens: 8192,
+        supportsImages: true,
+        supportsToolUse: true,
+        supportsStreaming: true,
+      },
+      {
+        id: "claude-3-5-haiku-20241022",
+        name: "Claude 3.5 Haiku",
+        contextWindow: 200000,
+        maxOutputTokens: 8192,
+        supportsImages: true,
+        supportsToolUse: true,
+        supportsStreaming: true,
+      },
+    ],
+    createClient: (config) => new AnthropicClient(config),
+  };
+}
+
+// ============================================================================
+// Google Provider
+// ============================================================================
+
+function createGoogleProvider(): LLMProvider {
+  return {
+    id: "google",
+    name: "Google",
+    type: "google",
+    models: [
+      {
+        id: "gemini-2.5-pro",
+        name: "Gemini 2.5 Pro",
+        contextWindow: 1000000,
+        maxOutputTokens: 65536,
+        supportsImages: true,
+        supportsToolUse: true,
+        supportsStreaming: true,
+      },
+      {
+        id: "gemini-2.5-flash",
+        name: "Gemini 2.5 Flash",
+        contextWindow: 1000000,
+        maxOutputTokens: 65536,
+        supportsImages: true,
+        supportsToolUse: true,
+        supportsStreaming: true,
+      },
+    ],
+    createClient: (config) => new GoogleClient(config),
+  };
+}
+
+// ============================================================================
+// Ollama Provider (Local)
+// ============================================================================
+
+function createOllamaProvider(): LLMProvider {
+  return {
+    id: "ollama",
+    name: "Ollama (Local)",
+    type: "ollama",
+    models: [
+      {
+        id: "llama3.1",
+        name: "Llama 3.1",
+        contextWindow: 128000,
+        maxOutputTokens: 8192,
+        supportsImages: false,
+        supportsToolUse: true,
+        supportsStreaming: true,
+      },
+      {
+        id: "qwen2.5-coder",
+        name: "Qwen 2.5 Coder",
+        contextWindow: 32768,
+        maxOutputTokens: 8192,
+        supportsImages: false,
+        supportsToolUse: true,
+        supportsStreaming: true,
+      },
+      {
+        id: "codellama",
+        name: "Code Llama",
+        contextWindow: 16384,
+        maxOutputTokens: 4096,
+        supportsImages: false,
+        supportsToolUse: false,
+        supportsStreaming: true,
+      },
+    ],
+    createClient: (config) => new OpenAICompatibleClient(config, "http://localhost:11434/v1"),
+  };
+}
+
+// ============================================================================
+// Custom Provider (OpenAI-compatible endpoints)
+// ============================================================================
+
+function createCustomProvider(): LLMProvider {
+  return {
+    id: "custom",
+    name: "Custom (OpenAI-compatible)",
+    type: "custom",
+    models: [
+      {
+        id: "custom-model",
+        name: "Custom Model",
+        contextWindow: 128000,
+        maxOutputTokens: 8192,
+        supportsImages: false,
+        supportsToolUse: true,
+        supportsStreaming: true,
+      },
+    ],
+    createClient: (config) => new OpenAICompatibleClient(config, config.baseUrl || "http://localhost:8080/v1"),
+  };
+}
+
+// ============================================================================
+// OpenAI-Compatible Client
+// ============================================================================
+
+class OpenAICompatibleClient implements LLMClient {
+  constructor(private config: ProviderConfig, private baseUrl: string) {}
+
+  async chat(messages: Message[], options?: ChatOptions): Promise<ChatResponse> {
+    const body = this.buildRequestBody(messages, options);
+
+    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...(this.config.apiKey ? { Authorization: `Bearer ${this.config.apiKey}` } : {}),
+        ...this.config.headers,
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`OpenAI API error (${response.status}): ${error}`);
+    }
+
+    const data = await response.json() as any;
+    return this.parseResponse(data);
+  }
+
+  async *stream(messages: Message[], options?: ChatOptions): AsyncIterable<StreamChunk> {
+    const body = { ...this.buildRequestBody(messages, options), stream: true };
+
+    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...(this.config.apiKey ? { Authorization: `Bearer ${this.config.apiKey}` } : {}),
+        ...this.config.headers,
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      throw new Error(`OpenAI API error: ${response.status}`);
+    }
+
+    const reader = response.body?.getReader();
+    if (!reader) throw new Error("No response body");
+
+    const decoder = new TextDecoder();
+    let buffer = "";
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+
+      for (const line of lines) {
+        if (line.startsWith("data: ")) {
+          const data = line.slice(6).trim();
+          if (data === "[DONE]") {
+            yield { type: "done", stopReason: "end_turn" };
+            return;
+          }
+          try {
+            const parsed = JSON.parse(data);
+            const delta = parsed.choices?.[0]?.delta;
+            if (delta?.content) {
+              yield { type: "text_delta", text: delta.content };
+            }
+          } catch {}
+        }
+      }
+    }
+  }
+
+  private buildRequestBody(messages: Message[], options?: ChatOptions): Record<string, unknown> {
+    const formattedMessages = messages.map((msg) => ({
+      role: msg.role === "tool" ? "tool" : msg.role,
+      content: this.formatContent(msg.content),
+    }));
+
+    if (options?.systemPrompt) {
+      formattedMessages.unshift({ role: "system", content: options.systemPrompt } as any);
+    }
+
+    const body: Record<string, unknown> = {
+      model: this.config.model,
+      messages: formattedMessages,
+      max_tokens: options?.maxTokens || this.config.maxTokens || 4096,
+      temperature: options?.temperature ?? this.config.temperature ?? 0.7,
+    };
+
+    if (options?.tools && options.tools.length > 0) {
+      body.tools = options.tools.map((tool) => ({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: {
+            type: "object",
+            properties: Object.fromEntries(
+              Object.entries(tool.parameters).map(([key, param]) => [
+                key,
+                { type: param.type, description: param.description },
+              ])
+            ),
+            required: Object.entries(tool.parameters)
+              .filter(([_, p]) => p.required)
+              .map(([key]) => key),
+          },
+        },
+      }));
+    }
+
+    return body;
+  }
+
+  private formatContent(content: MessageContent[]): string | Array<Record<string, unknown>> {
+    if (content.length === 1 && content[0].type === "text") {
+      return content[0].text;
+    }
+
+    return content.map((c) => {
+      switch (c.type) {
+        case "text":
+          return { type: "text", text: c.text };
+        case "image":
+          return { type: "image_url", image_url: { url: `data:${c.mimeType};base64,${c.data}` } };
+        case "tool_call":
+          return { type: "text", text: `[Tool call: ${c.name}]` };
+        case "tool_result":
+          return { type: "text", text: `[Tool result: ${typeof c.result === "string" ? c.result : JSON.stringify(c.result)}]` };
+      }
+    });
+  }
+
+  private parseResponse(data: any): ChatResponse {
+    const choice = data.choices?.[0];
+    const content: MessageContent[] = [];
+
+    if (choice?.message?.content) {
+      content.push({ type: "text", text: choice.message.content });
+    }
+
+    if (choice?.message?.tool_calls) {
+      for (const tc of choice.message.tool_calls) {
+        content.push({
+          type: "tool_call",
+          id: tc.id,
+          name: tc.function.name,
+          arguments: JSON.parse(tc.function.arguments || "{}"),
+        });
+      }
+    }
+
+    let stopReason: StopReason = "end_turn";
+    if (choice?.finish_reason === "tool_calls") stopReason = "tool_use";
+    else if (choice?.finish_reason === "length") stopReason = "max_tokens";
+    else if (choice?.finish_reason === "stop") stopReason = "end_turn";
+
+    return {
+      id: data.id || `resp_${Date.now()}`,
+      content,
+      usage: {
+        inputTokens: data.usage?.prompt_tokens || 0,
+        outputTokens: data.usage?.completion_tokens || 0,
+      },
+      stopReason,
+      model: data.model || this.config.model,
+    };
+  }
+}
+
+// ============================================================================
+// Anthropic Client
+// ============================================================================
+
+class AnthropicClient implements LLMClient {
+  constructor(private config: ProviderConfig) {}
+
+  async chat(messages: Message[], options?: ChatOptions): Promise<ChatResponse> {
+    const formattedMessages = this.formatMessages(messages);
+
+    const body: Record<string, unknown> = {
+      model: this.config.model,
+      max_tokens: options?.maxTokens || this.config.maxTokens || 8192,
+      messages: formattedMessages,
+    };
+
+    if (options?.systemPrompt) {
+      body.system = options.systemPrompt;
+    }
+
+    if (options?.tools && options.tools.length > 0) {
+      body.tools = options.tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        input_schema: {
+          type: "object",
+          properties: Object.fromEntries(
+            Object.entries(tool.parameters).map(([key, param]) => [
+              key,
+              { type: param.type, description: param.description },
+            ])
+          ),
+          required: Object.entries(tool.parameters)
+            .filter(([_, p]) => p.required)
+            .map(([key]) => key),
+        },
+      }));
+    }
+
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": this.config.apiKey || "",
+        "anthropic-version": "2023-06-01",
+        ...this.config.headers,
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Anthropic API error (${response.status}): ${error}`);
+    }
+
+    const data = await response.json() as any;
+    return this.parseResponse(data);
+  }
+
+  async *stream(messages: Message[], options?: ChatOptions): AsyncIterable<StreamChunk> {
+    // Simplified streaming - would implement SSE parsing in production
+    const response = await this.chat(messages, options);
+    for (const content of response.content) {
+      if (content.type === "text") {
+        yield { type: "text_delta", text: content.text };
+      }
+    }
+    yield { type: "done", stopReason: response.stopReason };
+  }
+
+  private formatMessages(messages: Message[]): Array<{ role: string; content: any }> {
+    return messages
+      .filter((m) => m.role !== "system")
+      .map((msg) => ({
+        role: msg.role === "tool" ? "user" : msg.role,
+        content: msg.content.map((c) => {
+          switch (c.type) {
+            case "text":
+              return { type: "text", text: c.text };
+            case "image":
+              return { type: "image", source: { type: "base64", media_type: c.mimeType, data: c.data } };
+            case "tool_call":
+              return { type: "tool_use", id: c.id, name: c.name, input: c.arguments };
+            case "tool_result":
+              return { type: "tool_result", tool_use_id: c.id, content: typeof c.result === "string" ? c.result : JSON.stringify(c.result) };
+          }
+        }),
+      }));
+  }
+
+  private parseResponse(data: any): ChatResponse {
+    const content: MessageContent[] = [];
+
+    for (const block of data.content || []) {
+      if (block.type === "text") {
+        content.push({ type: "text", text: block.text });
+      } else if (block.type === "tool_use") {
+        content.push({
+          type: "tool_call",
+          id: block.id,
+          name: block.name,
+          arguments: block.input || {},
+        });
+      }
+    }
+
+    let stopReason: StopReason = "end_turn";
+    if (data.stop_reason === "tool_use") stopReason = "tool_use";
+    else if (data.stop_reason === "max_tokens") stopReason = "max_tokens";
+
+    return {
+      id: data.id || `resp_${Date.now()}`,
+      content,
+      usage: {
+        inputTokens: data.usage?.input_tokens || 0,
+        outputTokens: data.usage?.output_tokens || 0,
+      },
+      stopReason,
+      model: data.model || this.config.model,
+    };
+  }
+}
+
+// ============================================================================
+// Google (Gemini) Client
+// ============================================================================
+
+class GoogleClient implements LLMClient {
+  constructor(private config: ProviderConfig) {}
+
+  async chat(messages: Message[], options?: ChatOptions): Promise<ChatResponse> {
+    const contents = this.formatMessages(messages);
+    const baseUrl = `https://generativelanguage.googleapis.com/v1beta/models/${this.config.model}:generateContent`;
+
+    const body: Record<string, unknown> = {
+      contents,
+      generationConfig: {
+        maxOutputTokens: options?.maxTokens || this.config.maxTokens || 8192,
+        temperature: options?.temperature ?? this.config.temperature ?? 0.7,
+      },
+    };
+
+    if (options?.systemPrompt) {
+      body.systemInstruction = { parts: [{ text: options.systemPrompt }] };
+    }
+
+    if (options?.tools && options.tools.length > 0) {
+      body.tools = [{
+        functionDeclarations: options.tools.map((tool) => ({
+          name: tool.name,
+          description: tool.description,
+          parameters: {
+            type: "OBJECT",
+            properties: Object.fromEntries(
+              Object.entries(tool.parameters).map(([key, param]) => [
+                key,
+                { type: param.type.toUpperCase(), description: param.description },
+              ])
+            ),
+            required: Object.entries(tool.parameters)
+              .filter(([_, p]) => p.required)
+              .map(([key]) => key),
+          },
+        })),
+      }];
+    }
+
+    const url = this.config.apiKey
+      ? `${baseUrl}?key=${this.config.apiKey}`
+      : baseUrl;
+
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...this.config.headers },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Google API error (${response.status}): ${error}`);
+    }
+
+    const data = await response.json() as any;
+    return this.parseResponse(data);
+  }
+
+  async *stream(messages: Message[], options?: ChatOptions): AsyncIterable<StreamChunk> {
+    const response = await this.chat(messages, options);
+    for (const content of response.content) {
+      if (content.type === "text") {
+        yield { type: "text_delta", text: content.text };
+      }
+    }
+    yield { type: "done", stopReason: response.stopReason };
+  }
+
+  private formatMessages(messages: Message[]): Array<{ role: string; parts: any[] }> {
+    return messages
+      .filter((m) => m.role !== "system")
+      .map((msg) => ({
+        role: msg.role === "assistant" ? "model" : "user",
+        parts: msg.content.map((c) => {
+          switch (c.type) {
+            case "text":
+              return { text: c.text };
+            case "image":
+              return { inlineData: { mimeType: c.mimeType, data: c.data } };
+            case "tool_call":
+              return { functionCall: { name: c.name, args: c.arguments } };
+            case "tool_result":
+              return { functionResponse: { name: c.name, response: { result: c.result } } };
+          }
+        }),
+      }));
+  }
+
+  private parseResponse(data: any): ChatResponse {
+    const content: MessageContent[] = [];
+    const candidate = data.candidates?.[0];
+
+    for (const part of candidate?.content?.parts || []) {
+      if (part.text) {
+        content.push({ type: "text", text: part.text });
+      } else if (part.functionCall) {
+        content.push({
+          type: "tool_call",
+          id: `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+          name: part.functionCall.name,
+          arguments: part.functionCall.args || {},
+        });
+      }
+    }
+
+    let stopReason: StopReason = "end_turn";
+    if (candidate?.finishReason === "FUNCTION_CALL") stopReason = "tool_use";
+    else if (candidate?.finishReason === "MAX_TOKENS") stopReason = "max_tokens";
+
+    return {
+      id: `resp_${Date.now()}`,
+      content,
+      usage: {
+        inputTokens: data.usageMetadata?.promptTokenCount || 0,
+        outputTokens: data.usageMetadata?.candidatesTokenCount || 0,
+      },
+      stopReason,
+      model: this.config.model,
+    };
+  }
+}