gencode-ai 0.4.0 → 0.5.0

package/src/core/providers/google.ts

@@ -0,0 +1,404 @@
+/**
+ * Google Provider Implementation
+ * Supports Gemini models: 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 { calculateCost } from '../pricing/calculator.js';
+import type {
+  LLMProvider,
+  ProviderClassMeta,
+  CompletionOptions,
+  CompletionResponse,
+  StreamChunk,
+  Message,
+  MessageContent,
+  ToolDefinition,
+  StopReason,
+  GoogleConfig,
+  JSONSchema,
+  ModelInfo,
+} from './types.js';
+
+export class GoogleProvider implements LLMProvider {
+  static readonly meta: ProviderClassMeta = {
+    provider: 'google',
+    authMethod: 'api_key',
+    envVars: ['GOOGLE_API_KEY', 'GEMINI_API_KEY'],
+    displayName: 'Google',
+    description: 'Google Generative AI (Gemini models)',
+  };
+
+  readonly name = 'google';
+  private client: GoogleGenerativeAI;
+  private apiKey: string;
+
+  constructor(config: GoogleConfig = {}) {
+    const apiKey = config.apiKey ?? process.env.GOOGLE_API_KEY ?? process.env.GEMINI_API_KEY;
+    if (!apiKey) {
+      throw new Error('Google 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, options.model);
+  }
+
+  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>;
+      thoughtSignature?: string;
+    }> = [];
+    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++}`;
+          // Capture thoughtSignature for Gemini 3+ models
+          const partAny = part as { thoughtSignature?: string };
+
+          // Emit reasoning content if available (Gemini 3+ thinking)
+          if (partAny.thoughtSignature) {
+            yield { type: 'reasoning', text: partAny.thoughtSignature };
+          }
+
+          functionCalls.push({
+            id,
+            name: fc.name,
+            args: (fc.args as Record<string, unknown>) ?? {},
+            thoughtSignature: partAny.thoughtSignature,
+          });
+          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,
+        thoughtSignature: fc.thoughtSignature,
+      });
+    }
+
+    const finalResponse = await result.response;
+    const stopReason = this.getStopReason(finalResponse, functionCalls.length > 0);
+
+    // Debug: Log usage metadata
+    if (process.env.DEBUG_TOKENS) {
+      console.error('[Google] usageMetadata:', JSON.stringify(finalResponse.usageMetadata, null, 2));
+    }
+
+    const usage = finalResponse.usageMetadata
+      ? {
+          inputTokens: finalResponse.usageMetadata.promptTokenCount ?? 0,
+          // Fix: candidatesTokenCount is unreliable, calculate from total - prompt
+          // Ensure outputTokens is never negative
+          outputTokens: Math.max(
+            0,
+            (finalResponse.usageMetadata.totalTokenCount ?? 0) - (finalResponse.usageMetadata.promptTokenCount ?? 0)
+          ),
+        }
+      : undefined;
+
+    // Warn if suspicious token count
+    if (usage && usage.outputTokens === 0 && content.length > 0) {
+      console.warn(
+        '[Google] Warning: usageMetadata shows 0 output tokens but content was returned. ' +
+        'This may indicate a Gemini API issue.'
+      );
+    }
+
+    const cost = usage ? calculateCost(this.name, options.model, usage) : undefined;
+
+    yield {
+      type: 'done',
+      response: {
+        content,
+        stopReason,
+        usage,
+        cost,
+      },
+    };
+  }
+
+  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 - include thoughtSignature for Gemini 3+
+        const fcPart: Part & { thoughtSignature?: string } = {
+          functionCall: {
+            name: item.name,
+            args: item.input,
+          },
+        };
+        if (item.thoughtSignature) {
+          fcPart.thoughtSignature = item.thoughtSignature;
+        }
+        parts.push(fcPart as Part);
+      } 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[] {
+    const result = [
+      {
+        functionDeclarations: tools.map((tool) => {
+          const convertedSchema = this.convertSchema(tool.parameters);
+
+          // Debug: Log Task tool schema
+          if (tool.name === 'Task' && process.env.DEBUG_SCHEMA) {
+            console.error('[Google] Task tool input schema:');
+            console.error(JSON.stringify(tool.parameters, null, 2));
+            console.error('[Google] Task tool converted schema:');
+            console.error(JSON.stringify(convertedSchema, null, 2));
+          }
+
+          return {
+            name: tool.name,
+            description: tool.description,
+            parameters: convertedSchema,
+          };
+        }),
+      },
+    ];
+
+    return result;
+  }
+
+  // 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;
+    }
+
+    if (schema.items) {
+      result.items = this.convertSchema(schema.items);
+    }
+
+    if (schema.enum) {
+      result.enum = schema.enum;
+    }
+
+    return result;
+  }
+
+  private convertResponse(result: GenerateContentResult, model: string): 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) {
+        // Capture thoughtSignature for Gemini 3+ models
+        const partAny = part as { thoughtSignature?: string };
+        content.push({
+          type: 'tool_use',
+          id: `call_${callIndex++}`,
+          name: part.functionCall.name,
+          input: (part.functionCall.args as Record<string, unknown>) ?? {},
+          thoughtSignature: partAny.thoughtSignature,
+        });
+      }
+    }
+
+    const hasFunctionCalls = parts.some((p) => 'functionCall' in p);
+
+    // Debug: Log usage metadata
+    if (process.env.DEBUG_TOKENS) {
+      console.error('[Google complete] usageMetadata:', JSON.stringify(response.usageMetadata, null, 2));
+    }
+
+    const usage = response.usageMetadata
+      ? {
+          inputTokens: response.usageMetadata.promptTokenCount ?? 0,
+          // Fix: candidatesTokenCount is unreliable, calculate from total - prompt
+          // Ensure outputTokens is never negative
+          outputTokens: Math.max(
+            0,
+            (response.usageMetadata.totalTokenCount ?? 0) - (response.usageMetadata.promptTokenCount ?? 0)
+          ),
+        }
+      : undefined;
+
+    // Warn if suspicious token count
+    if (usage && usage.outputTokens === 0 && content.length > 0) {
+      console.warn(
+        '[Google] Warning: usageMetadata shows 0 output tokens but content was returned. ' +
+        'This may indicate a Gemini API issue.'
+      );
+    }
+
+    const cost = usage ? calculateCost(this.name, model, usage) : undefined;
+
+    return {
+      content,
+      stopReason: this.getStopReason(response, hasFunctionCalls),
+      usage,
+      cost,
+    };
+  }
+
+  private getStopReason(response: GenerateContentResult['response'], hasFunctionCalls: boolean): StopReason {
+    if (hasFunctionCalls) {
+      return 'tool_use';
+    }
+
+    const finishReason = response.candidates?.[0]?.finishReason;
+
+    if (finishReason === 'MAX_TOKENS') {
+      return 'max_tokens';
+    }
+
+    if (finishReason === 'STOP') {
+      return 'end_turn';
+    }
+
+    if (finishReason === 'SAFETY' || finishReason === 'RECITATION') {
+      console.warn(`[Google] Content blocked by ${finishReason} filter`);
+      return 'end_turn';
+    }
+
+    console.warn(`[Google] Unknown finishReason: ${finishReason}`);
+    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/core/providers/index.ts

@@ -0,0 +1,155 @@
+/**
+ * LLM Providers - Unified interface for OpenAI, Anthropic, Gemini, and Vertex AI
+ */
+
+export * from './types.js';
+export { OpenAIProvider } from './openai.js';
+export { AnthropicProvider } from './anthropic.js';
+export { GoogleProvider } from './google.js';
+export { AnthropicVertexProvider } from './anthropic-vertex.js';
+
+import type {
+  LLMProvider,
+  Provider,
+  AuthMethod,
+  OpenAIConfig,
+  AnthropicConfig,
+  GoogleConfig,
+  VertexAIConfig,
+} from './types.js';
+import { OpenAIProvider } from './openai.js';
+import { AnthropicProvider } from './anthropic.js';
+import { GoogleProvider } from './google.js';
+import { AnthropicVertexProvider } from './anthropic-vertex.js';
+
+// Legacy type alias for backward compatibility
+/** @deprecated Use Provider instead */
+export type ProviderName = Provider;
+
+export type ProviderConfigMap = {
+  openai: OpenAIConfig;
+  anthropic: AnthropicConfig;
+  google: GoogleConfig;
+};
+
+export interface CreateProviderOptions {
+  provider: Provider;
+  authMethod?: AuthMethod;
+  config?: OpenAIConfig | AnthropicConfig | GoogleConfig | VertexAIConfig;
+}
+
+/**
+ * Create a provider instance by provider and auth method
+ * If authMethod is not provided, defaults to 'api_key'
+ */
+export function createProvider(options: CreateProviderOptions): LLMProvider {
+  const { provider, authMethod = 'api_key', config } = options;
+
+  // Map provider + authMethod to the correct implementation
+  if (provider === 'anthropic') {
+    if (authMethod === 'vertex') {
+      return new AnthropicVertexProvider(config as VertexAIConfig);
+    } else if (authMethod === 'api_key') {
+      return new AnthropicProvider(config as AnthropicConfig);
+    }
+    throw new Error(`Unsupported auth method for anthropic: ${authMethod}`);
+  }
+
+  if (provider === 'openai') {
+    if (authMethod === 'api_key') {
+      return new OpenAIProvider(config as OpenAIConfig);
+    }
+    throw new Error(`Unsupported auth method for openai: ${authMethod}`);
+  }
+
+  if (provider === 'google') {
+    if (authMethod === 'api_key') {
+      return new GoogleProvider(config as GoogleConfig);
+    }
+    throw new Error(`Unsupported auth method for google: ${authMethod}`);
+  }
+
+  throw new Error(`Unknown provider: ${provider}`);
+}
+
+/**
+ * Infer provider from model name
+ * Note: This only returns the provider, not the auth method
+ * For Vertex AI models (claude-*@version), this returns 'anthropic'
+ */
+export function inferProvider(model: string): Provider {
+  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 (including Vertex AI format with @)
+  if (modelLower.includes('claude')) {
+    return 'anthropic';
+  }
+
+  // Google models (Gemini)
+  if (modelLower.includes('gemini') || modelLower.includes('palm')) {
+    return 'google';
+  }
+
+  // Default to OpenAI (most common)
+  return 'openai';
+}
+
+/**
+ * Infer auth method from model name
+ * Returns undefined if auth method cannot be inferred
+ */
+export function inferAuthMethod(model: string): AuthMethod | undefined {
+  const modelLower = model.toLowerCase();
+
+  // Vertex AI models (Claude models with @ version suffix like claude-sonnet-4-5@20250929)
+  if (modelLower.includes('claude') && modelLower.includes('@')) {
+    return 'vertex';
+  }
+
+  // For other models, we can't reliably infer auth method
+  return undefined;
+}
+
+/**
+ * Common model aliases
+ */
+export const ModelAliases: Record<
+  string,
+  { provider: Provider; authMethod?: AuthMethod; 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 (Direct API)
+  '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' },
+
+  // Google (Gemini models)
+  'gemini-2.0-flash': { provider: 'google', model: 'gemini-2.0-flash' },
+  'gemini-1.5-pro': { provider: 'google', model: 'gemini-1.5-pro' },
+  'gemini-1.5-flash': { provider: 'google', model: 'gemini-1.5-flash' },
+
+  // Anthropic via Vertex AI
+  'vertex-sonnet': { provider: 'anthropic', authMethod: 'vertex', model: 'claude-sonnet-4-5@20250929' },
+  'vertex-haiku': { provider: 'anthropic', authMethod: 'vertex', model: 'claude-haiku-4-5@20251001' },
+  'vertex-opus': { provider: 'anthropic', authMethod: 'vertex', model: 'claude-opus-4-1@20250805' },
+};