gencode-ai 0.1.3 → 0.2.0

package/src/pricing/models.ts

@@ -0,0 +1,334 @@
+/**
+ * Model pricing database
+ * Prices are per 1M tokens in USD
+ * Updated: January 2025
+ */
+
+import { ModelPricing } from './types.js';
+
+/**
+ * Pricing data for all supported models
+ * Source: Official provider pricing pages as of January 2025
+ */
+export const MODEL_PRICING: ModelPricing[] = [
+  // Anthropic Claude Models
+  {
+    provider: 'anthropic',
+    model: 'claude-opus-4-5',
+    inputPer1M: 15.0,
+    outputPer1M: 75.0,
+    effectiveDate: '2025-01-01',
+  },
+  {
+    provider: 'anthropic',
+    model: 'claude-opus-4',
+    inputPer1M: 15.0,
+    outputPer1M: 75.0,
+    effectiveDate: '2024-11-01',
+  },
+  {
+    provider: 'anthropic',
+    model: 'claude-sonnet-4-5',
+    inputPer1M: 3.0,
+    outputPer1M: 15.0,
+    effectiveDate: '2025-01-01',
+  },
+  {
+    provider: 'anthropic',
+    model: 'claude-sonnet-4',
+    inputPer1M: 3.0,
+    outputPer1M: 15.0,
+    effectiveDate: '2024-10-22',
+  },
+  {
+    provider: 'anthropic',
+    model: 'claude-3-5-sonnet-20241022',
+    inputPer1M: 3.0,
+    outputPer1M: 15.0,
+    effectiveDate: '2024-10-22',
+  },
+  {
+    provider: 'anthropic',
+    model: 'claude-3-5-sonnet-20240620',
+    inputPer1M: 3.0,
+    outputPer1M: 15.0,
+    effectiveDate: '2024-06-20',
+  },
+  {
+    provider: 'anthropic',
+    model: 'claude-haiku-3-5',
+    inputPer1M: 0.8,
+    outputPer1M: 4.0,
+    effectiveDate: '2024-11-01',
+  },
+  {
+    provider: 'anthropic',
+    model: 'claude-3-5-haiku-20241022',
+    inputPer1M: 0.8,
+    outputPer1M: 4.0,
+    effectiveDate: '2024-10-22',
+  },
+  {
+    provider: 'anthropic',
+    model: 'claude-3-haiku-20240307',
+    inputPer1M: 0.25,
+    outputPer1M: 1.25,
+    effectiveDate: '2024-03-07',
+  },
+  {
+    provider: 'anthropic',
+    model: 'claude-3-opus-20240229',
+    inputPer1M: 15.0,
+    outputPer1M: 75.0,
+    effectiveDate: '2024-02-29',
+  },
+
+  // OpenAI Models
+  {
+    provider: 'openai',
+    model: 'gpt-4o',
+    inputPer1M: 2.5,
+    outputPer1M: 10.0,
+    effectiveDate: '2024-08-06',
+  },
+  {
+    provider: 'openai',
+    model: 'gpt-4o-2024-11-20',
+    inputPer1M: 2.5,
+    outputPer1M: 10.0,
+    effectiveDate: '2024-11-20',
+  },
+  {
+    provider: 'openai',
+    model: 'gpt-4o-2024-08-06',
+    inputPer1M: 2.5,
+    outputPer1M: 10.0,
+    effectiveDate: '2024-08-06',
+  },
+  {
+    provider: 'openai',
+    model: 'gpt-4o-2024-05-13',
+    inputPer1M: 5.0,
+    outputPer1M: 15.0,
+    effectiveDate: '2024-05-13',
+  },
+  {
+    provider: 'openai',
+    model: 'gpt-4o-mini',
+    inputPer1M: 0.15,
+    outputPer1M: 0.6,
+    effectiveDate: '2024-07-18',
+  },
+  {
+    provider: 'openai',
+    model: 'gpt-4o-mini-2024-07-18',
+    inputPer1M: 0.15,
+    outputPer1M: 0.6,
+    effectiveDate: '2024-07-18',
+  },
+  {
+    provider: 'openai',
+    model: 'gpt-4-turbo',
+    inputPer1M: 10.0,
+    outputPer1M: 30.0,
+    effectiveDate: '2024-04-09',
+  },
+  {
+    provider: 'openai',
+    model: 'gpt-4-turbo-2024-04-09',
+    inputPer1M: 10.0,
+    outputPer1M: 30.0,
+    effectiveDate: '2024-04-09',
+  },
+  {
+    provider: 'openai',
+    model: 'gpt-4',
+    inputPer1M: 30.0,
+    outputPer1M: 60.0,
+    effectiveDate: '2023-03-14',
+  },
+  {
+    provider: 'openai',
+    model: 'gpt-3.5-turbo',
+    inputPer1M: 0.5,
+    outputPer1M: 1.5,
+    effectiveDate: '2023-11-06',
+  },
+  {
+    provider: 'openai',
+    model: 'o1',
+    inputPer1M: 15.0,
+    outputPer1M: 60.0,
+    effectiveDate: '2024-12-17',
+  },
+  {
+    provider: 'openai',
+    model: 'o1-2024-12-17',
+    inputPer1M: 15.0,
+    outputPer1M: 60.0,
+    effectiveDate: '2024-12-17',
+  },
+  {
+    provider: 'openai',
+    model: 'o1-preview',
+    inputPer1M: 15.0,
+    outputPer1M: 60.0,
+    effectiveDate: '2024-09-12',
+  },
+  {
+    provider: 'openai',
+    model: 'o1-preview-2024-09-12',
+    inputPer1M: 15.0,
+    outputPer1M: 60.0,
+    effectiveDate: '2024-09-12',
+  },
+  {
+    provider: 'openai',
+    model: 'o1-mini',
+    inputPer1M: 3.0,
+    outputPer1M: 12.0,
+    effectiveDate: '2024-09-12',
+  },
+  {
+    provider: 'openai',
+    model: 'o1-mini-2024-09-12',
+    inputPer1M: 3.0,
+    outputPer1M: 12.0,
+    effectiveDate: '2024-09-12',
+  },
+
+  // Google Gemini Models
+  {
+    provider: 'gemini',
+    model: 'gemini-2.0-flash-exp',
+    inputPer1M: 0.0,
+    outputPer1M: 0.0,
+    effectiveDate: '2024-12-11',
+  },
+  {
+    provider: 'gemini',
+    model: 'gemini-2.0-flash',
+    inputPer1M: 0.075,
+    outputPer1M: 0.3,
+    effectiveDate: '2025-01-01',
+  },
+  {
+    provider: 'gemini',
+    model: 'gemini-exp-1206',
+    inputPer1M: 0.0,
+    outputPer1M: 0.0,
+    effectiveDate: '2024-12-06',
+  },
+  {
+    provider: 'gemini',
+    model: 'gemini-1.5-pro',
+    inputPer1M: 1.25,
+    outputPer1M: 5.0,
+    effectiveDate: '2024-05-14',
+  },
+  {
+    provider: 'gemini',
+    model: 'gemini-1.5-pro-002',
+    inputPer1M: 1.25,
+    outputPer1M: 5.0,
+    effectiveDate: '2024-09-24',
+  },
+  {
+    provider: 'gemini',
+    model: 'gemini-1.5-flash',
+    inputPer1M: 0.075,
+    outputPer1M: 0.3,
+    effectiveDate: '2024-05-14',
+  },
+  {
+    provider: 'gemini',
+    model: 'gemini-1.5-flash-002',
+    inputPer1M: 0.075,
+    outputPer1M: 0.3,
+    effectiveDate: '2024-09-24',
+  },
+  {
+    provider: 'gemini',
+    model: 'gemini-1.5-flash-8b',
+    inputPer1M: 0.0375,
+    outputPer1M: 0.15,
+    effectiveDate: '2024-10-03',
+  },
+
+  // Google Vertex AI (same pricing as Gemini)
+  {
+    provider: 'vertex-ai',
+    model: 'gemini-2.0-flash-exp',
+    inputPer1M: 0.0,
+    outputPer1M: 0.0,
+    effectiveDate: '2024-12-11',
+  },
+  {
+    provider: 'vertex-ai',
+    model: 'gemini-2.0-flash',
+    inputPer1M: 0.075,
+    outputPer1M: 0.3,
+    effectiveDate: '2025-01-01',
+  },
+  {
+    provider: 'vertex-ai',
+    model: 'gemini-exp-1206',
+    inputPer1M: 0.0,
+    outputPer1M: 0.0,
+    effectiveDate: '2024-12-06',
+  },
+  {
+    provider: 'vertex-ai',
+    model: 'gemini-1.5-pro',
+    inputPer1M: 1.25,
+    outputPer1M: 5.0,
+    effectiveDate: '2024-05-14',
+  },
+  {
+    provider: 'vertex-ai',
+    model: 'gemini-1.5-pro-002',
+    inputPer1M: 1.25,
+    outputPer1M: 5.0,
+    effectiveDate: '2024-09-24',
+  },
+  {
+    provider: 'vertex-ai',
+    model: 'gemini-1.5-flash',
+    inputPer1M: 0.075,
+    outputPer1M: 0.3,
+    effectiveDate: '2024-05-14',
+  },
+  {
+    provider: 'vertex-ai',
+    model: 'gemini-1.5-flash-002',
+    inputPer1M: 0.075,
+    outputPer1M: 0.3,
+    effectiveDate: '2024-09-24',
+  },
+  {
+    provider: 'vertex-ai',
+    model: 'gemini-1.5-flash-8b',
+    inputPer1M: 0.0375,
+    outputPer1M: 0.15,
+    effectiveDate: '2024-10-03',
+  },
+];
+
+/**
+ * Get pricing for a specific model
+ */
+export function getModelPricing(
+  provider: string,
+  model: string
+): ModelPricing | undefined {
+  return MODEL_PRICING.find(
+    (p) => p.provider === provider && p.model === model
+  );
+}
+
+/**
+ * Get all pricing for a provider
+ */
+export function getProviderPricing(provider: string): ModelPricing[] {
+  return MODEL_PRICING.filter((p) => p.provider === provider);
+}

package/src/pricing/types.ts

@@ -0,0 +1,32 @@
+/**
+ * Pricing and cost tracking types
+ */
+
+/**
+ * Token usage information
+ */
+export interface TokenUsage {
+  inputTokens: number;
+  outputTokens: number;
+}
+
+/**
+ * Cost estimate in USD
+ */
+export interface CostEstimate {
+  inputCost: number;
+  outputCost: number;
+  totalCost: number;
+  currency: string; // 'USD'
+}
+
+/**
+ * Model pricing per 1M tokens (USD)
+ */
+export interface ModelPricing {
+  provider: string;
+  model: string;
+  inputPer1M: number; // USD per 1M input tokens
+  outputPer1M: number; // USD per 1M output tokens
+  effectiveDate?: string; // When this pricing became effective
+}

package/src/providers/anthropic.ts

@@ -4,6 +4,7 @@
  */
 
 import Anthropic from '@anthropic-ai/sdk';
+import { calculateCost } from '../pricing/calculator.js';
 import type {
   LLMProvider,
   CompletionOptions,
@@ -45,7 +46,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 +95,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 +175,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,6 +5,7 @@
 
 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,
   CompletionOptions,
@@ -47,7 +48,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 +116,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 +243,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 +267,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/openai.ts

@@ -4,6 +4,7 @@
  */
 
 import OpenAI from 'openai';
+import { calculateCost } from '../pricing/calculator.js';
 import type {
   LLMProvider,
   CompletionOptions,
@@ -44,7 +45,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 +196,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 +220,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,
     };
   }
 

package/src/providers/types.ts

@@ -3,6 +3,8 @@
  * Abstracts differences between OpenAI, Anthropic, and Gemini APIs
  */
 
+import type { CostEstimate } from '../pricing/types.js';
+
 // ============================================================================
 // Message Types
 // ============================================================================
@@ -92,6 +94,7 @@ export interface CompletionResponse {
     inputTokens: number;
     outputTokens: number;
   };
+  cost?: CostEstimate;
 }
 
 // ============================================================================

package/src/providers/vertex-ai.ts

@@ -9,6 +9,7 @@
  */
 
 import { GoogleAuth } from 'google-auth-library';
+import { calculateCost } from '../pricing/calculator.js';
 import type {
   LLMProvider,
   CompletionOptions,
@@ -210,7 +211,7 @@ export class VertexAIProvider implements LLMProvider {
     }
 
     const data = (await response.json()) as VertexAIResponse;
-    return this.convertResponse(data);
+    return this.convertResponse(data, options.model);
   }
 
   async *stream(options: CompletionOptions): AsyncGenerator<StreamChunk, void, unknown> {
@@ -337,15 +338,20 @@ export class VertexAIProvider implements LLMProvider {
     // Build final response
     const content = this.buildFinalContent(contentBlocks, toolInputBuffers);
 
+    const usage = {
+      inputTokens,
+      outputTokens,
+    };
+
+    const cost = calculateCost(this.name, options.model, usage);
+
     yield {
       type: 'done',
       response: {
         content,
         stopReason,
-        usage: {
-          inputTokens,
-          outputTokens,
-        },
+        usage,
+        cost,
       },
     };
   }
@@ -449,14 +455,19 @@ export class VertexAIProvider implements LLMProvider {
     }));
   }
 
-  private convertResponse(response: VertexAIResponse): CompletionResponse {
+  private convertResponse(response: VertexAIResponse, 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/session/manager.ts

@@ -326,6 +326,15 @@ export class SessionManager {
     }
   }
 
+  /**
+   * Remove the last message from current session
+   */
+  removeLastMessage(): void {
+    if (this.currentSession && this.currentSession.messages.length > 0) {
+      this.currentSession.messages.pop();
+    }
+  }
+
   /**
    * Export session to JSON
    */

package/src/tools/index.ts

@@ -28,6 +28,9 @@ export type {
   AskUserQuestionResult,
 } from './builtin/ask-user.js';
 
+// Plan mode tools
+export { enterPlanModeTool, exitPlanModeTool } from '../planning/index.js';
+
 import { ToolRegistry } from './registry.js';
 import { readTool } from './builtin/read.js';
 import { writeTool } from './builtin/write.js';
@@ -39,6 +42,7 @@ import { webfetchTool } from './builtin/webfetch.js';
 import { websearchTool } from './builtin/websearch.js';
 import { todowriteTool } from './builtin/todowrite.js';
 import { askUserQuestionTool } from './builtin/ask-user.js';
+import { enterPlanModeTool, exitPlanModeTool } from '../planning/index.js';
 
 /**
  * Create a registry with all built-in tools
@@ -56,6 +60,8 @@ export function createDefaultRegistry(): ToolRegistry {
     websearchTool,
     todowriteTool,
     askUserQuestionTool,
+    enterPlanModeTool,
+    exitPlanModeTool,
   ]);
   return registry;
 }
@@ -74,4 +80,6 @@ export const builtinTools = [
   websearchTool,
   todowriteTool,
   askUserQuestionTool,
+  enterPlanModeTool,
+  exitPlanModeTool,
 ];