gencode-ai 0.1.3 → 0.3.0

package/src/providers/anthropic.ts

@@ -4,8 +4,10 @@
  */
 
 import Anthropic from '@anthropic-ai/sdk';
+import { calculateCost } from '../pricing/calculator.js';
 import type {
   LLMProvider,
+  ProviderClassMeta,
   CompletionOptions,
   CompletionResponse,
   StreamChunk,
@@ -22,6 +24,14 @@ type AnthropicTool = Anthropic.Tool;
 type AnthropicContent = Anthropic.ContentBlockParam;
 
 export class AnthropicProvider implements LLMProvider {
+  static readonly meta: ProviderClassMeta = {
+    provider: 'anthropic',
+    authMethod: 'api_key',
+    envVars: ['ANTHROPIC_API_KEY'],
+    displayName: 'Direct API',
+    description: 'Direct API access',
+  };
+
   readonly name = 'anthropic';
   private client: Anthropic;
 
@@ -45,7 +55,7 @@ export class AnthropicProvider implements LLMProvider {
       temperature: options.temperature,
     });
 
-    return this.convertResponse(response);
+    return this.convertResponse(response, options.model);
   }
 
   async *stream(options: CompletionOptions): AsyncGenerator<StreamChunk, void, unknown> {
@@ -94,15 +104,20 @@ export class AnthropicProvider implements LLMProvider {
     const finalMessage = await stream.finalMessage();
     const content = this.convertContent(finalMessage.content);
 
+    const usage = {
+      inputTokens: finalMessage.usage.input_tokens,
+      outputTokens: finalMessage.usage.output_tokens,
+    };
+
+    const cost = calculateCost(this.name, options.model, usage);
+
     yield {
       type: 'done',
       response: {
         content,
         stopReason: this.convertStopReason(finalMessage.stop_reason),
-        usage: {
-          inputTokens: finalMessage.usage.input_tokens,
-          outputTokens: finalMessage.usage.output_tokens,
-        },
+        usage,
+        cost,
       },
     };
   }
@@ -169,14 +184,19 @@ export class AnthropicProvider implements LLMProvider {
     }));
   }
 
-  private convertResponse(response: Anthropic.Message): CompletionResponse {
+  private convertResponse(response: Anthropic.Message, model: string): CompletionResponse {
+    const usage = {
+      inputTokens: response.usage.input_tokens,
+      outputTokens: response.usage.output_tokens,
+    };
+
+    const cost = calculateCost(this.name, model, usage);
+
     return {
       content: this.convertContent(response.content),
       stopReason: this.convertStopReason(response.stop_reason),
-      usage: {
-        inputTokens: response.usage.input_tokens,
-        outputTokens: response.usage.output_tokens,
-      },
+      usage,
+      cost,
     };
   }
 

package/src/providers/gemini.ts

@@ -5,8 +5,10 @@
 
 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,
@@ -20,6 +22,14 @@ import type {
 } from './types.js';
 
 export class GeminiProvider implements LLMProvider {
+  static readonly meta: ProviderClassMeta = {
+    provider: 'gemini',
+    authMethod: 'api_key',
+    envVars: ['GOOGLE_API_KEY', 'GEMINI_API_KEY'],
+    displayName: 'Direct API',
+    description: 'Direct API access',
+  };
+
   readonly name = 'gemini';
   private client: GoogleGenerativeAI;
   private apiKey: string;
@@ -47,7 +57,7 @@ export class GeminiProvider implements LLMProvider {
     const contents = this.convertMessages(options.messages);
     const result = await model.generateContent({ contents });
 
-    return this.convertResponse(result);
+    return this.convertResponse(result, options.model);
   }
 
   async *stream(options: CompletionOptions): AsyncGenerator<StreamChunk, void, unknown> {
@@ -115,17 +125,22 @@ export class GeminiProvider implements LLMProvider {
     const finalResponse = await result.response;
     const stopReason = this.getStopReason(finalResponse, functionCalls.length > 0);
 
+    const usage = finalResponse.usageMetadata
+      ? {
+          inputTokens: finalResponse.usageMetadata.promptTokenCount ?? 0,
+          outputTokens: finalResponse.usageMetadata.candidatesTokenCount ?? 0,
+        }
+      : undefined;
+
+    const cost = usage ? calculateCost(this.name, options.model, usage) : undefined;
+
     yield {
       type: 'done',
       response: {
         content,
         stopReason,
-        usage: finalResponse.usageMetadata
-          ? {
-              inputTokens: finalResponse.usageMetadata.promptTokenCount ?? 0,
-              outputTokens: finalResponse.usageMetadata.candidatesTokenCount ?? 0,
-            }
-          : undefined,
+        usage,
+        cost,
       },
     };
   }
@@ -237,7 +252,7 @@ export class GeminiProvider implements LLMProvider {
     return result;
   }
 
-  private convertResponse(result: GenerateContentResult): CompletionResponse {
+  private convertResponse(result: GenerateContentResult, model: string): CompletionResponse {
     const response = result.response;
     const parts = response.candidates?.[0]?.content?.parts ?? [];
     const content: MessageContent[] = [];
@@ -261,15 +276,20 @@ export class GeminiProvider implements LLMProvider {
 
     const hasFunctionCalls = parts.some((p) => 'functionCall' in p);
 
+    const usage = response.usageMetadata
+      ? {
+          inputTokens: response.usageMetadata.promptTokenCount ?? 0,
+          outputTokens: response.usageMetadata.candidatesTokenCount ?? 0,
+        }
+      : undefined;
+
+    const cost = usage ? calculateCost(this.name, model, usage) : undefined;
+
     return {
       content,
       stopReason: this.getStopReason(response, hasFunctionCalls),
-      usage: response.usageMetadata
-        ? {
-            inputTokens: response.usageMetadata.promptTokenCount ?? 0,
-            outputTokens: response.usageMetadata.candidatesTokenCount ?? 0,
-          }
-        : undefined,
+      usage,
+      cost,
     };
   }
 

package/src/providers/index.ts

@@ -6,56 +6,80 @@ export * from './types.js';
 export { OpenAIProvider } from './openai.js';
 export { AnthropicProvider } from './anthropic.js';
 export { GeminiProvider } from './gemini.js';
-export { VertexAIProvider } from './vertex-ai.js';
+export { AnthropicVertexProvider } from './vertex-ai.js';
 
-import type { LLMProvider, OpenAIConfig, AnthropicConfig, GeminiConfig, VertexAIConfig } from './types.js';
+import type {
+  LLMProvider,
+  Provider,
+  AuthMethod,
+  OpenAIConfig,
+  AnthropicConfig,
+  GeminiConfig,
+  VertexAIConfig,
+} from './types.js';
 import { OpenAIProvider } from './openai.js';
 import { AnthropicProvider } from './anthropic.js';
 import { GeminiProvider } from './gemini.js';
-import { VertexAIProvider } from './vertex-ai.js';
+import { AnthropicVertexProvider } from './vertex-ai.js';
+
+// Legacy type alias for backward compatibility
+/** @deprecated Use Provider instead */
+export type ProviderName = Provider;
 
-export type ProviderName = 'openai' | 'anthropic' | 'gemini' | 'vertex-ai';
 export type ProviderConfigMap = {
   openai: OpenAIConfig;
   anthropic: AnthropicConfig;
   gemini: GeminiConfig;
-  'vertex-ai': VertexAIConfig;
 };
 
-export interface CreateProviderOptions<T extends ProviderName = ProviderName> {
-  provider: T;
-  config?: ProviderConfigMap[T];
+export interface CreateProviderOptions {
+  provider: Provider;
+  authMethod?: AuthMethod;
+  config?: OpenAIConfig | AnthropicConfig | GeminiConfig | VertexAIConfig;
 }
 
 /**
- * Create a provider instance by name
+ * Create a provider instance by provider and auth method
+ * If authMethod is not provided, defaults to 'api_key'
  */
 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);
-    case 'vertex-ai':
-      return new VertexAIProvider(options.config as VertexAIConfig);
-    default:
-      throw new Error(`Unknown provider: ${options.provider}`);
+  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 === 'gemini') {
+    if (authMethod === 'api_key') {
+      return new GeminiProvider(config as GeminiConfig);
+    }
+    throw new Error(`Unsupported auth method for gemini: ${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): ProviderName {
+export function inferProvider(model: string): Provider {
   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-ai';
-  }
-
   // OpenAI models
   if (
     modelLower.includes('gpt') ||
@@ -68,7 +92,7 @@ export function inferProvider(model: string): ProviderName {
     return 'openai';
   }
 
-  // Anthropic models
+  // Anthropic models (including Vertex AI format with @)
   if (modelLower.includes('claude')) {
     return 'anthropic';
   }
@@ -82,10 +106,29 @@ export function inferProvider(model: string): ProviderName {
   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: ProviderName; model: string }> = {
+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' },
@@ -94,7 +137,7 @@ export const ModelAliases: Record<string, { provider: ProviderName; model: strin
   'o1-mini': { provider: 'openai', model: 'o1-mini' },
   'o3-mini': { provider: 'openai', model: 'o3-mini' },
 
-  // Anthropic
+  // 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' },
@@ -105,8 +148,8 @@ export const ModelAliases: Record<string, { provider: ProviderName; model: strin
   'gemini-1.5-pro': { provider: 'gemini', model: 'gemini-1.5-pro' },
   'gemini-1.5-flash': { provider: 'gemini', model: 'gemini-1.5-flash' },
 
-  // Vertex AI (Claude on GCP)
-  'vertex-sonnet': { provider: 'vertex-ai', model: 'claude-sonnet-4-5@20250929' },
-  'vertex-haiku': { provider: 'vertex-ai', model: 'claude-haiku-4-5@20251001' },
-  'vertex-opus': { provider: 'vertex-ai', model: 'claude-opus-4-1@20250805' },
+  // 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' },
 };

package/src/providers/openai.ts

@@ -4,8 +4,10 @@
  */
 
 import OpenAI from 'openai';
+import { calculateCost } from '../pricing/calculator.js';
 import type {
   LLMProvider,
+  ProviderClassMeta,
   CompletionOptions,
   CompletionResponse,
   StreamChunk,
@@ -21,6 +23,14 @@ type OpenAIMessage = OpenAI.Chat.Completions.ChatCompletionMessageParam;
 type OpenAITool = OpenAI.Chat.Completions.ChatCompletionTool;
 
 export class OpenAIProvider implements LLMProvider {
+  static readonly meta: ProviderClassMeta = {
+    provider: 'openai',
+    authMethod: 'api_key',
+    envVars: ['OPENAI_API_KEY'],
+    displayName: 'Direct API',
+    description: 'Direct API access',
+  };
+
   readonly name = 'openai';
   private client: OpenAI;
 
@@ -44,7 +54,7 @@ export class OpenAIProvider implements LLMProvider {
       temperature: options.temperature,
     });
 
-    return this.convertResponse(response);
+    return this.convertResponse(response, options.model);
   }
 
   async *stream(options: CompletionOptions): AsyncGenerator<StreamChunk, void, unknown> {
@@ -195,7 +205,10 @@ export class OpenAIProvider implements LLMProvider {
     }));
   }
 
-  private convertResponse(response: OpenAI.Chat.Completions.ChatCompletion): CompletionResponse {
+  private convertResponse(
+    response: OpenAI.Chat.Completions.ChatCompletion,
+    model: string
+  ): CompletionResponse {
     const choice = response.choices[0];
     const content: MessageContent[] = [];
 
@@ -216,15 +229,20 @@ export class OpenAIProvider implements LLMProvider {
       }
     }
 
+    const usage = response.usage
+      ? {
+          inputTokens: response.usage.prompt_tokens,
+          outputTokens: response.usage.completion_tokens,
+        }
+      : undefined;
+
+    const cost = usage ? calculateCost(this.name, model, usage) : undefined;
+
     return {
       content,
       stopReason: this.convertStopReason(choice.finish_reason),
-      usage: response.usage
-        ? {
-            inputTokens: response.usage.prompt_tokens,
-            outputTokens: response.usage.completion_tokens,
-          }
-        : undefined,
+      usage,
+      cost,
     };
   }