gencode-ai 0.1.0

package/src/providers/gemini.ts

@@ -0,0 +1,295 @@
+/**
+ * Google Gemini Provider Implementation
+ * Supports Gemini 1.5 Pro, Gemini 1.5 Flash, Gemini 2.0, etc.
+ */
+
+import { GoogleGenerativeAI, SchemaType } from '@google/generative-ai';
+import type { Content, Part, Tool, GenerateContentResult } from '@google/generative-ai';
+import type {
+  LLMProvider,
+  CompletionOptions,
+  CompletionResponse,
+  StreamChunk,
+  Message,
+  MessageContent,
+  ToolDefinition,
+  StopReason,
+  GeminiConfig,
+  JSONSchema,
+  ModelInfo,
+} from './types.js';
+
+export class GeminiProvider implements LLMProvider {
+  readonly name = 'gemini';
+  private client: GoogleGenerativeAI;
+  private apiKey: string;
+
+  constructor(config: GeminiConfig = {}) {
+    const apiKey = config.apiKey ?? process.env.GOOGLE_API_KEY ?? process.env.GEMINI_API_KEY;
+    if (!apiKey) {
+      throw new Error('Gemini API key is required. Set GOOGLE_API_KEY or GEMINI_API_KEY.');
+    }
+    this.apiKey = apiKey;
+    this.client = new GoogleGenerativeAI(apiKey);
+  }
+
+  async complete(options: CompletionOptions): Promise<CompletionResponse> {
+    const model = this.client.getGenerativeModel({
+      model: options.model,
+      systemInstruction: options.systemPrompt,
+      generationConfig: {
+        maxOutputTokens: options.maxTokens,
+        temperature: options.temperature,
+      },
+      tools: options.tools ? this.convertTools(options.tools) : undefined,
+    });
+
+    const contents = this.convertMessages(options.messages);
+    const result = await model.generateContent({ contents });
+
+    return this.convertResponse(result);
+  }
+
+  async *stream(options: CompletionOptions): AsyncGenerator<StreamChunk, void, unknown> {
+    const model = this.client.getGenerativeModel({
+      model: options.model,
+      systemInstruction: options.systemPrompt,
+      generationConfig: {
+        maxOutputTokens: options.maxTokens,
+        temperature: options.temperature,
+      },
+      tools: options.tools ? this.convertTools(options.tools) : undefined,
+    });
+
+    const contents = this.convertMessages(options.messages);
+    const result = await model.generateContentStream({ contents });
+
+    let textContent = '';
+    const functionCalls: Array<{ id: string; name: string; args: Record<string, unknown> }> = [];
+    let callIndex = 0;
+
+    for await (const chunk of result.stream) {
+      const parts = chunk.candidates?.[0]?.content?.parts ?? [];
+
+      for (const part of parts) {
+        if ('text' in part && part.text) {
+          textContent += part.text;
+          yield { type: 'text', text: part.text };
+        } else if ('functionCall' in part && part.functionCall) {
+          const fc = part.functionCall;
+          const id = `call_${callIndex++}`;
+          functionCalls.push({
+            id,
+            name: fc.name,
+            args: (fc.args as Record<string, unknown>) ?? {},
+          });
+          yield { type: 'tool_start', id, name: fc.name };
+          yield { type: 'tool_input', id, input: JSON.stringify(fc.args) };
+        }
+      }
+    }
+
+    // Build final response
+    const content: MessageContent[] = [];
+    if (textContent) {
+      content.push({ type: 'text', text: textContent });
+    }
+    for (const fc of functionCalls) {
+      content.push({
+        type: 'tool_use',
+        id: fc.id,
+        name: fc.name,
+        input: fc.args,
+      });
+    }
+
+    const finalResponse = await result.response;
+    const stopReason = this.getStopReason(finalResponse, functionCalls.length > 0);
+
+    yield {
+      type: 'done',
+      response: {
+        content,
+        stopReason,
+        usage: finalResponse.usageMetadata
+          ? {
+              inputTokens: finalResponse.usageMetadata.promptTokenCount ?? 0,
+              outputTokens: finalResponse.usageMetadata.candidatesTokenCount ?? 0,
+            }
+          : undefined,
+      },
+    };
+  }
+
+  private convertMessages(messages: Message[]): Content[] {
+    const contents: Content[] = [];
+
+    for (const msg of messages) {
+      // Skip system messages - handled via systemInstruction
+      if (msg.role === 'system') {
+        continue;
+      }
+
+      const role = msg.role === 'assistant' ? 'model' : 'user';
+      const parts = this.convertToParts(msg.content, role);
+
+      if (parts.length > 0) {
+        contents.push({ role, parts });
+      }
+    }
+
+    return contents;
+  }
+
+  private convertToParts(content: string | MessageContent[], role: string): Part[] {
+    if (typeof content === 'string') {
+      return [{ text: content }];
+    }
+
+    const parts: Part[] = [];
+
+    for (const item of content) {
+      if (item.type === 'text') {
+        parts.push({ text: item.text });
+      } else if (item.type === 'tool_use' && role === 'model') {
+        // Function call from model
+        parts.push({
+          functionCall: {
+            name: item.name,
+            args: item.input,
+          },
+        });
+      } else if (item.type === 'tool_result' && role === 'user') {
+        // Function response
+        parts.push({
+          functionResponse: {
+            name: item.toolUseId, // Use toolUseId as name reference
+            response: { result: item.content },
+          },
+        });
+      }
+    }
+
+    return parts;
+  }
+
+  private convertTools(tools: ToolDefinition[]): Tool[] {
+    return [
+      {
+        functionDeclarations: tools.map((tool) => ({
+          name: tool.name,
+          description: tool.description,
+          parameters: this.convertSchema(tool.parameters),
+        })),
+      },
+    ];
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private convertSchema(schema: JSONSchema): any {
+    const convertType = (type: string): SchemaType => {
+      switch (type) {
+        case 'string':
+          return SchemaType.STRING;
+        case 'number':
+        case 'integer':
+          return SchemaType.NUMBER;
+        case 'boolean':
+          return SchemaType.BOOLEAN;
+        case 'array':
+          return SchemaType.ARRAY;
+        case 'object':
+        default:
+          return SchemaType.OBJECT;
+      }
+    };
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const result: any = {
+      type: convertType(schema.type),
+      description: schema.description,
+    };
+
+    if (schema.properties) {
+      result.properties = {};
+      for (const [key, value] of Object.entries(schema.properties)) {
+        result.properties[key] = this.convertSchema(value);
+      }
+    }
+
+    if (schema.required) {
+      result.required = schema.required;
+    }
+
+    return result;
+  }
+
+  private convertResponse(result: GenerateContentResult): CompletionResponse {
+    const response = result.response;
+    const parts = response.candidates?.[0]?.content?.parts ?? [];
+    const content: MessageContent[] = [];
+    let callIndex = 0;
+
+    for (const part of parts) {
+      if ('text' in part && part.text) {
+        content.push({ type: 'text', text: part.text });
+      } else if ('functionCall' in part && part.functionCall) {
+        content.push({
+          type: 'tool_use',
+          id: `call_${callIndex++}`,
+          name: part.functionCall.name,
+          input: (part.functionCall.args as Record<string, unknown>) ?? {},
+        });
+      }
+    }
+
+    const hasFunctionCalls = parts.some((p) => 'functionCall' in p);
+
+    return {
+      content,
+      stopReason: this.getStopReason(response, hasFunctionCalls),
+      usage: response.usageMetadata
+        ? {
+            inputTokens: response.usageMetadata.promptTokenCount ?? 0,
+            outputTokens: response.usageMetadata.candidatesTokenCount ?? 0,
+          }
+        : undefined,
+    };
+  }
+
+  private getStopReason(response: GenerateContentResult['response'], hasFunctionCalls: boolean): StopReason {
+    if (hasFunctionCalls) {
+      return 'tool_use';
+    }
+
+    const finishReason = response.candidates?.[0]?.finishReason;
+    switch (finishReason) {
+      case 'MAX_TOKENS':
+        return 'max_tokens';
+      case 'STOP':
+      default:
+        return 'end_turn';
+    }
+  }
+
+  async listModels(): Promise<ModelInfo[]> {
+    const response = await fetch(
+      `https://generativelanguage.googleapis.com/v1beta/models?key=${this.apiKey}`
+    );
+    const data = (await response.json()) as {
+      models?: Array<{
+        name: string;
+        displayName: string;
+        description?: string;
+        supportedGenerationMethods?: string[];
+      }>;
+    };
+    return (data.models || [])
+      .filter((m) => m.supportedGenerationMethods?.includes('generateContent'))
+      .map((m) => ({
+        id: m.name.replace('models/', ''),
+        name: m.displayName,
+        description: m.description,
+      }));
+  }
+}

package/src/providers/index.ts

@@ -0,0 +1,97 @@
+/**
+ * LLM Providers - Unified interface for OpenAI, Anthropic, and Gemini
+ */
+
+export * from './types.js';
+export { OpenAIProvider } from './openai.js';
+export { AnthropicProvider } from './anthropic.js';
+export { GeminiProvider } from './gemini.js';
+
+import type { LLMProvider, OpenAIConfig, AnthropicConfig, GeminiConfig } from './types.js';
+import { OpenAIProvider } from './openai.js';
+import { AnthropicProvider } from './anthropic.js';
+import { GeminiProvider } from './gemini.js';
+
+export type ProviderName = 'openai' | 'anthropic' | 'gemini';
+export type ProviderConfigMap = {
+  openai: OpenAIConfig;
+  anthropic: AnthropicConfig;
+  gemini: GeminiConfig;
+};
+
+export interface CreateProviderOptions<T extends ProviderName = ProviderName> {
+  provider: T;
+  config?: ProviderConfigMap[T];
+}
+
+/**
+ * Create a provider instance by name
+ */
+export function createProvider(options: CreateProviderOptions): LLMProvider {
+  switch (options.provider) {
+    case 'openai':
+      return new OpenAIProvider(options.config as OpenAIConfig);
+    case 'anthropic':
+      return new AnthropicProvider(options.config as AnthropicConfig);
+    case 'gemini':
+      return new GeminiProvider(options.config as GeminiConfig);
+    default:
+      throw new Error(`Unknown provider: ${options.provider}`);
+  }
+}
+
+/**
+ * Infer provider from model name
+ */
+export function inferProvider(model: string): ProviderName {
+  const modelLower = model.toLowerCase();
+
+  // OpenAI models
+  if (
+    modelLower.includes('gpt') ||
+    modelLower.includes('o1') ||
+    modelLower.includes('o3') ||
+    modelLower.startsWith('text-') ||
+    modelLower.startsWith('davinci') ||
+    modelLower.startsWith('curie')
+  ) {
+    return 'openai';
+  }
+
+  // Anthropic models
+  if (modelLower.includes('claude')) {
+    return 'anthropic';
+  }
+
+  // Gemini models
+  if (modelLower.includes('gemini') || modelLower.includes('palm')) {
+    return 'gemini';
+  }
+
+  // Default to OpenAI (most common)
+  return 'openai';
+}
+
+/**
+ * Common model aliases
+ */
+export const ModelAliases: Record<string, { provider: ProviderName; model: string }> = {
+  // OpenAI
+  'gpt-4o': { provider: 'openai', model: 'gpt-4o' },
+  'gpt-4o-mini': { provider: 'openai', model: 'gpt-4o-mini' },
+  'gpt-4-turbo': { provider: 'openai', model: 'gpt-4-turbo' },
+  'o1': { provider: 'openai', model: 'o1' },
+  'o1-mini': { provider: 'openai', model: 'o1-mini' },
+  'o3-mini': { provider: 'openai', model: 'o3-mini' },
+
+  // Anthropic
+  'claude-opus': { provider: 'anthropic', model: 'claude-opus-4-5-20251101' },
+  'claude-sonnet': { provider: 'anthropic', model: 'claude-sonnet-4-20250514' },
+  'claude-haiku': { provider: 'anthropic', model: 'claude-haiku-4-20250514' },
+  'claude-3.5-sonnet': { provider: 'anthropic', model: 'claude-3-5-sonnet-20241022' },
+
+  // Gemini
+  'gemini-2.0-flash': { provider: 'gemini', model: 'gemini-2.0-flash' },
+  'gemini-1.5-pro': { provider: 'gemini', model: 'gemini-1.5-pro' },
+  'gemini-1.5-flash': { provider: 'gemini', model: 'gemini-1.5-flash' },
+};

package/src/providers/openai.ts

@@ -0,0 +1,261 @@
+/**
+ * OpenAI Provider Implementation
+ * Supports GPT-4, GPT-4o, GPT-3.5-turbo, and other OpenAI models
+ */
+
+import OpenAI from 'openai';
+import type {
+  LLMProvider,
+  CompletionOptions,
+  CompletionResponse,
+  StreamChunk,
+  Message,
+  MessageContent,
+  ToolDefinition,
+  StopReason,
+  OpenAIConfig,
+  ModelInfo,
+} from './types.js';
+
+type OpenAIMessage = OpenAI.Chat.Completions.ChatCompletionMessageParam;
+type OpenAITool = OpenAI.Chat.Completions.ChatCompletionTool;
+
+export class OpenAIProvider implements LLMProvider {
+  readonly name = 'openai';
+  private client: OpenAI;
+
+  constructor(config: OpenAIConfig = {}) {
+    this.client = new OpenAI({
+      apiKey: config.apiKey ?? process.env.OPENAI_API_KEY,
+      baseURL: config.baseURL,
+      organization: config.organization,
+    });
+  }
+
+  async complete(options: CompletionOptions): Promise<CompletionResponse> {
+    const messages = this.convertMessages(options.messages, options.systemPrompt);
+    const tools = options.tools ? this.convertTools(options.tools) : undefined;
+
+    const response = await this.client.chat.completions.create({
+      model: options.model,
+      messages,
+      tools,
+      max_tokens: options.maxTokens,
+      temperature: options.temperature,
+    });
+
+    return this.convertResponse(response);
+  }
+
+  async *stream(options: CompletionOptions): AsyncGenerator<StreamChunk, void, unknown> {
+    const messages = this.convertMessages(options.messages, options.systemPrompt);
+    const tools = options.tools ? this.convertTools(options.tools) : undefined;
+
+    const stream = await this.client.chat.completions.create({
+      model: options.model,
+      messages,
+      tools,
+      max_tokens: options.maxTokens,
+      temperature: options.temperature,
+      stream: true,
+    });
+
+    const toolCalls: Map<number, { id: string; name: string; arguments: string }> = new Map();
+    let textContent = '';
+    let finishReason: string | null = null;
+
+    for await (const chunk of stream) {
+      const delta = chunk.choices[0]?.delta;
+      finishReason = chunk.choices[0]?.finish_reason ?? finishReason;
+
+      if (delta?.content) {
+        textContent += delta.content;
+        yield { type: 'text', text: delta.content };
+      }
+
+      if (delta?.tool_calls) {
+        for (const tc of delta.tool_calls) {
+          const existing = toolCalls.get(tc.index);
+          if (existing) {
+            if (tc.function?.arguments) {
+              existing.arguments += tc.function.arguments;
+              yield { type: 'tool_input', id: existing.id, input: tc.function.arguments };
+            }
+          } else if (tc.id && tc.function?.name) {
+            toolCalls.set(tc.index, {
+              id: tc.id,
+              name: tc.function.name,
+              arguments: tc.function.arguments ?? '',
+            });
+            yield { type: 'tool_start', id: tc.id, name: tc.function.name };
+            if (tc.function.arguments) {
+              yield { type: 'tool_input', id: tc.id, input: tc.function.arguments };
+            }
+          }
+        }
+      }
+    }
+
+    // Build final response
+    const content: MessageContent[] = [];
+    if (textContent) {
+      content.push({ type: 'text', text: textContent });
+    }
+    for (const tc of toolCalls.values()) {
+      content.push({
+        type: 'tool_use',
+        id: tc.id,
+        name: tc.name,
+        input: JSON.parse(tc.arguments || '{}'),
+      });
+    }
+
+    yield {
+      type: 'done',
+      response: {
+        content,
+        stopReason: this.convertStopReason(finishReason),
+      },
+    };
+  }
+
+  private convertMessages(messages: Message[], systemPrompt?: string): OpenAIMessage[] {
+    const result: OpenAIMessage[] = [];
+
+    if (systemPrompt) {
+      result.push({ role: 'system', content: systemPrompt });
+    }
+
+    for (const msg of messages) {
+      if (msg.role === 'system') {
+        result.push({ role: 'system', content: this.getTextContent(msg.content) });
+      } else if (msg.role === 'user') {
+        // Check if message contains tool results
+        if (Array.isArray(msg.content)) {
+          const toolResults = msg.content.filter((c) => c.type === 'tool_result');
+          if (toolResults.length > 0) {
+            for (const tr of toolResults) {
+              if (tr.type === 'tool_result') {
+                result.push({
+                  role: 'tool',
+                  tool_call_id: tr.toolUseId,
+                  content: tr.content,
+                });
+              }
+            }
+            continue;
+          }
+        }
+        result.push({ role: 'user', content: this.getTextContent(msg.content) });
+      } else if (msg.role === 'assistant') {
+        const assistantMsg: OpenAI.Chat.Completions.ChatCompletionAssistantMessageParam = {
+          role: 'assistant',
+        };
+
+        if (Array.isArray(msg.content)) {
+          const textParts = msg.content.filter((c) => c.type === 'text');
+          const toolUses = msg.content.filter((c) => c.type === 'tool_use');
+
+          if (textParts.length > 0) {
+            assistantMsg.content = textParts.map((t) => (t as { text: string }).text).join('');
+          }
+
+          if (toolUses.length > 0) {
+            assistantMsg.tool_calls = toolUses.map((t) => {
+              const tu = t as { id: string; name: string; input: Record<string, unknown> };
+              return {
+                id: tu.id,
+                type: 'function' as const,
+                function: {
+                  name: tu.name,
+                  arguments: JSON.stringify(tu.input),
+                },
+              };
+            });
+          }
+        } else {
+          assistantMsg.content = msg.content;
+        }
+
+        result.push(assistantMsg);
+      }
+    }
+
+    return result;
+  }
+
+  private convertTools(tools: ToolDefinition[]): OpenAITool[] {
+    return tools.map((tool) => ({
+      type: 'function' as const,
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters,
+      },
+    }));
+  }
+
+  private convertResponse(response: OpenAI.Chat.Completions.ChatCompletion): CompletionResponse {
+    const choice = response.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) {
+        if (tc.type === 'function' && tc.function) {
+          content.push({
+            type: 'tool_use',
+            id: tc.id,
+            name: tc.function.name,
+            input: JSON.parse(tc.function.arguments || '{}'),
+          });
+        }
+      }
+    }
+
+    return {
+      content,
+      stopReason: this.convertStopReason(choice.finish_reason),
+      usage: response.usage
+        ? {
+            inputTokens: response.usage.prompt_tokens,
+            outputTokens: response.usage.completion_tokens,
+          }
+        : undefined,
+    };
+  }
+
+  private convertStopReason(reason: string | null): StopReason {
+    switch (reason) {
+      case 'tool_calls':
+        return 'tool_use';
+      case 'length':
+        return 'max_tokens';
+      case 'stop':
+      default:
+        return 'end_turn';
+    }
+  }
+
+  private getTextContent(content: string | MessageContent[]): string {
+    if (typeof content === 'string') {
+      return content;
+    }
+    return content
+      .filter((c) => c.type === 'text')
+      .map((c) => (c as { text: string }).text)
+      .join('');
+  }
+
+  async listModels(): Promise<ModelInfo[]> {
+    const list = await this.client.models.list();
+    const models: ModelInfo[] = [];
+    for await (const model of list) {
+      models.push({ id: model.id, name: model.id });
+    }
+    return models.sort((a, b) => a.id.localeCompare(b.id));
+  }
+}