gencode-ai 0.3.0 → 0.4.0

package/src/providers/index.ts

@@ -5,7 +5,7 @@
 export * from './types.js';
 export { OpenAIProvider } from './openai.js';
 export { AnthropicProvider } from './anthropic.js';
-export { GeminiProvider } from './gemini.js';
+export { GoogleProvider } from './google.js';
 export { AnthropicVertexProvider } from './vertex-ai.js';
 
 import type {
@@ -14,12 +14,12 @@ import type {
   AuthMethod,
   OpenAIConfig,
   AnthropicConfig,
-  GeminiConfig,
+  GoogleConfig,
   VertexAIConfig,
 } from './types.js';
 import { OpenAIProvider } from './openai.js';
 import { AnthropicProvider } from './anthropic.js';
-import { GeminiProvider } from './gemini.js';
+import { GoogleProvider } from './google.js';
 import { AnthropicVertexProvider } from './vertex-ai.js';
 
 // Legacy type alias for backward compatibility
@@ -29,13 +29,13 @@ export type ProviderName = Provider;
 export type ProviderConfigMap = {
   openai: OpenAIConfig;
   anthropic: AnthropicConfig;
-  gemini: GeminiConfig;
+  google: GoogleConfig;
 };
 
 export interface CreateProviderOptions {
   provider: Provider;
   authMethod?: AuthMethod;
-  config?: OpenAIConfig | AnthropicConfig | GeminiConfig | VertexAIConfig;
+  config?: OpenAIConfig | AnthropicConfig | GoogleConfig | VertexAIConfig;
 }
 
 /**
@@ -62,11 +62,11 @@ export function createProvider(options: CreateProviderOptions): LLMProvider {
     throw new Error(`Unsupported auth method for openai: ${authMethod}`);
   }
 
-  if (provider === 'gemini') {
+  if (provider === 'google') {
     if (authMethod === 'api_key') {
-      return new GeminiProvider(config as GeminiConfig);
+      return new GoogleProvider(config as GoogleConfig);
     }
-    throw new Error(`Unsupported auth method for gemini: ${authMethod}`);
+    throw new Error(`Unsupported auth method for google: ${authMethod}`);
   }
 
   throw new Error(`Unknown provider: ${provider}`);
@@ -97,9 +97,9 @@ export function inferProvider(model: string): Provider {
     return 'anthropic';
   }
 
-  // Gemini models
+  // Google models (Gemini)
   if (modelLower.includes('gemini') || modelLower.includes('palm')) {
-    return 'gemini';
+    return 'google';
   }
 
   // Default to OpenAI (most common)
@@ -143,10 +143,10 @@ export const ModelAliases: Record<
   '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' },
+  // 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' },

package/src/providers/openai.ts

@@ -247,13 +247,20 @@ export class OpenAIProvider implements LLMProvider {
   }
 
   private convertStopReason(reason: string | null): StopReason {
+    if (!reason) {
+      console.warn('[OpenAI] Warning: Received null finish_reason, defaulting to end_turn');
+      return 'end_turn';
+    }
+
     switch (reason) {
       case 'tool_calls':
         return 'tool_use';
       case 'length':
         return 'max_tokens';
       case 'stop':
+        return 'end_turn';
       default:
+        console.warn(`[OpenAI] Unknown finish_reason: ${reason}, defaulting to end_turn`);
         return 'end_turn';
     }
   }

package/src/providers/registry.ts

@@ -7,7 +7,7 @@ import type { SearchProviderName } from './search/types.js';
 import { AnthropicProvider } from './anthropic.js';
 import { AnthropicVertexProvider } from './vertex-ai.js';
 import { OpenAIProvider } from './openai.js';
-import { GeminiProvider } from './gemini.js';
+import { GoogleProvider } from './google.js';
 
 // ============================================================================
 // LLM Provider Classes
@@ -26,7 +26,7 @@ export const PROVIDER_CLASSES: ProviderClass[] = [
   AnthropicProvider,
   AnthropicVertexProvider,
   OpenAIProvider,
-  GeminiProvider,
+  GoogleProvider,
 ];
 
 /**
@@ -41,7 +41,7 @@ export interface ProviderMeta {
 export const PROVIDER_METADATA: ProviderMeta[] = [
   { id: 'anthropic', name: 'Anthropic', popularity: 1 },
   { id: 'openai', name: 'OpenAI', popularity: 2 },
-  { id: 'gemini', name: 'Google Gemini', popularity: 3 },
+  { id: 'google', name: 'Google', popularity: 3 },
 ];
 
 // ============================================================================

package/src/providers/types.ts

@@ -12,7 +12,7 @@ import type { CostEstimate } from '../pricing/types.js';
 /**
  * Provider - Semantic layer (only 3 providers)
  */
-export type Provider = 'anthropic' | 'openai' | 'gemini';
+export type Provider = 'anthropic' | 'openai' | 'google';
 
 /**
  * Authentication method for providers
@@ -113,6 +113,7 @@ export interface CompletionOptions {
   maxTokens?: number;
   temperature?: number;
   stream?: boolean;
+  signal?: AbortSignal; // For cancellation support
 }
 
 export type StopReason = 'end_turn' | 'tool_use' | 'max_tokens' | 'stop_sequence';
@@ -123,6 +124,15 @@ export interface CompletionResponse {
   usage?: {
     inputTokens: number;
     outputTokens: number;
+    /** Reasoning tokens (for thinking models like o1/o3) */
+    reasoningTokens?: number;
+    /** Cache statistics (Anthropic prompt caching) */
+    cache?: {
+      /** Cache hit tokens (~10% cost) */
+      readTokens: number;
+      /** Cache creation tokens */
+      writeTokens: number;
+    };
   };
   cost?: CostEstimate;
 }
@@ -150,6 +160,11 @@ export interface StreamChunkToolInput {
   input: string; // Partial JSON string
 }
 
+export interface StreamChunkReasoning {
+  type: 'reasoning';
+  text: string; // Reasoning content from o1/o3/Gemini 3+ models
+}
+
 export interface StreamChunkDone {
   type: 'done';
   response: CompletionResponse;
@@ -164,6 +179,7 @@ export type StreamChunk =
   | StreamChunkText
   | StreamChunkToolStart
   | StreamChunkToolInput
+  | StreamChunkReasoning
   | StreamChunkDone
   | StreamChunkError;
 
@@ -175,6 +191,10 @@ export interface ModelInfo {
   id: string;
   name: string;
   description?: string;
+  /** Model context window size (for compression decisions) */
+  contextWindow?: number;
+  /** Model output limit (for compression decisions) */
+  outputLimit?: number;
 }
 
 export interface LLMProvider {
@@ -194,6 +214,16 @@ export interface LLMProvider {
    * List available models from the provider
    */
   listModels(): Promise<ModelInfo[]>;
+
+  /**
+   * Get current model name (optional - for backward compatibility)
+   */
+  getModel?(): string;
+
+  /**
+   * Get model information (for compression decisions)
+   */
+  getModelInfo?(model: string): ModelInfo;
 }
 
 // ============================================================================
@@ -211,7 +241,7 @@ export interface AnthropicConfig {
   baseURL?: string;
 }
 
-export interface GeminiConfig {
+export interface GoogleConfig {
   apiKey?: string;
 }
 
@@ -221,4 +251,4 @@ export interface VertexAIConfig {
   accessToken?: string;
 }
 
-export type ProviderConfig = OpenAIConfig | AnthropicConfig | GeminiConfig | VertexAIConfig;
+export type ProviderConfig = OpenAIConfig | AnthropicConfig | GoogleConfig | VertexAIConfig;

package/src/session/compression/engine.ts

@@ -0,0 +1,406 @@
+/**
+ * Three-layer compression engine (inspired by OpenCode)
+ * Layer 1: Tool output pruning (fast, no cost)
+ * Layer 2: Compaction summarization (LLM-based, medium cost)
+ * Layer 3: Message filtering (recovery optimization)
+ */
+
+import type { Message, MessageContent } from '../../providers/types.js';
+import type {
+  CompressionConfig,
+  ConversationSummary,
+  ToolUsageSummary,
+  TokenUsage,
+  ModelInfo,
+} from './types.js';
+import { DEFAULT_COMPRESSION_CONFIG } from './types.js';
+
+// Provider interface (minimal subset needed for compression)
+interface LLMProvider {
+  complete(options: {
+    model: string;
+    messages: Message[];
+    maxTokens?: number;
+  }): Promise<{ content: string | MessageContent[] }>;
+  getModel?(): string;
+}
+
+/**
+ * Compression engine implementing OpenCode's three-layer strategy
+ */
+export class CompressionEngine {
+  private provider: LLMProvider;
+  private config: CompressionConfig;
+
+  // OpenCode constants
+  private readonly CHARS_PER_TOKEN = 4;
+
+  constructor(provider: LLMProvider, config?: Partial<CompressionConfig>) {
+    this.provider = provider;
+    this.config = { ...DEFAULT_COMPRESSION_CONFIG, ...config };
+  }
+
+  /**
+   * Estimate tokens using 4:1 character-to-token ratio (OpenCode approach)
+   */
+  estimateTokens(text: string): number {
+    return Math.max(0, Math.round((text || '').length / this.CHARS_PER_TOKEN));
+  }
+
+  /**
+   * Calculate total tokens from messages
+   */
+  calculateTotalTokens(messages: Message[], tokenUsage?: TokenUsage): number {
+    // If we have actual token usage data, use it
+    if (tokenUsage) {
+      return (
+        tokenUsage.input +
+        (tokenUsage.cache?.read || 0) +
+        tokenUsage.output +
+        (tokenUsage.reasoning || 0)
+      );
+    }
+
+    // Otherwise estimate
+    let total = 0;
+    for (const msg of messages) {
+      const content =
+        typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content);
+      total += this.estimateTokens(content);
+    }
+    return total;
+  }
+
+  /**
+   * Calculate usable context space (OpenCode logic)
+   */
+  getUsableContext(model: ModelInfo): number {
+    const maxOutput = Math.min(
+      model.outputLimit || 4096,
+      this.config.reservedOutputTokens
+    );
+    return model.contextWindow - maxOutput;
+  }
+
+  /**
+   * Check if compression is needed (OpenCode isOverflow logic)
+   */
+  needsCompression(
+    messages: Message[],
+    model: ModelInfo,
+    tokenUsage?: TokenUsage
+  ): {
+    needed: boolean;
+    strategy: 'prune' | 'compact' | 'none';
+    usagePercent?: number;
+    shouldWarn?: boolean;
+  } {
+    if (!this.config.enabled) {
+      return { needed: false, strategy: 'none' };
+    }
+
+    const totalTokens = this.calculateTotalTokens(messages, tokenUsage);
+    const usable = this.getUsableContext(model);
+    const usagePercent = (totalTokens / usable) * 100;
+
+    // Warn at 80% usage
+    const shouldWarn = usagePercent >= 80;
+
+    // Auto-compress at 90% usage or if exceeding usable space
+    const needed = totalTokens > usable || usagePercent >= 90;
+
+    if (!needed) {
+      return { needed: false, strategy: 'none', usagePercent, shouldWarn };
+    }
+
+    // Determine compression strategy
+    let strategy: 'prune' | 'compact' = 'compact';
+    if (totalTokens > this.config.pruneMinimum && this.config.enablePruning) {
+      strategy = 'prune';
+    }
+
+    return { needed: true, strategy, usagePercent, shouldWarn };
+  }
+
+  /**
+   * Layer 1: Tool output pruning (OpenCode pruning logic)
+   * Fast and cost-free - removes old tool results
+   */
+  async pruneToolOutputs(messages: Message[]): Promise<{
+    pruned: boolean;
+    prunedCount: number;
+    savedTokens: number;
+  }> {
+    const totalTokens = this.calculateTotalTokens(messages);
+    if (totalTokens < this.config.pruneMinimum) {
+      return { pruned: false, prunedCount: 0, savedTokens: 0 };
+    }
+
+    // Collect recent tool outputs (protect last 40k tokens)
+    let protectedTokens = 0;
+    const protectedIndices = new Set<number>();
+
+    for (
+      let i = messages.length - 1;
+      i >= 0 && protectedTokens < this.config.pruneProtect;
+      i--
+    ) {
+      const msg = messages[i];
+      if (this.hasToolResults(msg)) {
+        const msgTokens = this.calculateTotalTokens([msg]);
+        protectedTokens += msgTokens;
+        protectedIndices.add(i);
+      }
+    }
+
+    // Prune older tool outputs
+    let prunedCount = 0;
+    let savedTokens = 0;
+
+    for (let i = 0; i < messages.length; i++) {
+      if (!protectedIndices.has(i) && this.hasToolResults(messages[i])) {
+        const before = this.calculateTotalTokens([messages[i]]);
+        this.clearToolResults(messages[i]);
+        const after = this.calculateTotalTokens([messages[i]]);
+        savedTokens += before - after;
+        prunedCount++;
+      }
+    }
+
+    return { pruned: prunedCount > 0, prunedCount, savedTokens };
+  }
+
+  /**
+   * Layer 2: Compaction summarization (OpenCode compaction logic)
+   * Generates continuation prompt focusing on future context needs
+   */
+  async compact(
+    messages: Message[],
+    range: [number, number]
+  ): Promise<ConversationSummary> {
+    const toSummarize = messages.slice(range[0], range[1] + 1);
+
+    // Extract structured information
+    const filesModified = this.extractFilesModified(toSummarize);
+    const toolsUsed = this.extractToolUsage(toSummarize);
+    const keyDecisions = await this.extractKeyDecisions(toSummarize);
+
+    // Generate continuation prompt (OpenCode style)
+    const continuationPrompt = await this.generateContinuationPrompt(toSummarize);
+
+    return {
+      id: this.generateId(),
+      type: 'compaction',
+      coveringMessages: range,
+      content: continuationPrompt,
+      keyDecisions,
+      filesModified,
+      toolsUsed,
+      generatedAt: new Date().toISOString(),
+      estimatedTokens: this.estimateTokens(continuationPrompt),
+    };
+  }
+
+  /**
+   * Generate continuation prompt (OpenCode style)
+   * Focus on what's needed to continue, not just what was done
+   */
+  private async generateContinuationPrompt(messages: Message[]): Promise<string> {
+    const prompt = `Provide a detailed prompt for continuing our conversation above.
+
+Focus on information that would be helpful for continuing the conversation:
+1. What we accomplished so far
+2. What we're currently working on
+3. Which files we modified and key changes made
+4. What we plan to do next
+5. Any important context or decisions that would be needed
+
+Remember: The new session will NOT have access to our full conversation history,
+so include all essential context needed to continue working effectively.
+
+Be technical and specific. Use structured bullet points.
+
+Conversation:
+${this.formatMessagesForSummary(messages)}
+
+Continuation Prompt:`;
+
+    const response = await this.provider.complete({
+      model: this.config.model ?? (this.provider.getModel?.() || 'unknown'),
+      messages: [{ role: 'user', content: prompt }],
+      maxTokens: 1500, // Larger for continuation prompt
+    });
+
+    return this.extractTextContent(response.content);
+  }
+
+  /**
+   * Extract files modified from tool uses
+   */
+  private extractFilesModified(messages: Message[]): string[] {
+    const files = new Set<string>();
+
+    for (const msg of messages) {
+      if (typeof msg.content !== 'string') {
+        for (const block of msg.content) {
+          if (block.type === 'tool_use') {
+            if (['Write', 'Edit'].includes(block.name)) {
+              const filePath = (block.input as any).file_path;
+              if (filePath) files.add(filePath);
+            }
+          }
+        }
+      }
+    }
+
+    return Array.from(files);
+  }
+
+  /**
+   * Extract tool usage statistics
+   */
+  private extractToolUsage(messages: Message[]): ToolUsageSummary[] {
+    const toolStats = new Map<string, { count: number; uses: string[] }>();
+
+    for (const msg of messages) {
+      if (typeof msg.content !== 'string') {
+        for (const block of msg.content) {
+          if (block.type === 'tool_use') {
+            const stats = toolStats.get(block.name) || { count: 0, uses: [] };
+            stats.count++;
+
+            if (stats.uses.length < 3) {
+              stats.uses.push(this.summarizeToolUse(block));
+            }
+
+            toolStats.set(block.name, stats);
+          }
+        }
+      }
+    }
+
+    return Array.from(toolStats.entries()).map(([tool, stats]) => ({
+      tool,
+      count: stats.count,
+      notableUses: stats.uses,
+    }));
+  }
+
+  /**
+   * Extract key decisions from conversation
+   */
+  private async extractKeyDecisions(messages: Message[]): Promise<string[]> {
+    const decisions: string[] = [];
+    const decisionIndicators = ['decided to', 'chose to', 'will use', 'going with'];
+
+    for (const msg of messages) {
+      const content = typeof msg.content === 'string' ? msg.content : '';
+
+      // Look for decision indicators
+      const hasDecision = decisionIndicators.some((indicator) =>
+        content.includes(indicator)
+      );
+
+      if (hasDecision) {
+        const decision = this.extractDecisionContext(content);
+        if (decision) decisions.push(decision);
+      }
+    }
+
+    return decisions.slice(0, 5); // Keep top 5
+  }
+
+  // ===== Helper Methods =====
+
+  /**
+   * Check if message contains tool results
+   */
+  private hasToolResults(message: Message): boolean {
+    if (typeof message.content === 'string') return false;
+    return message.content.some((block) => block.type === 'tool_result');
+  }
+
+  /**
+   * Clear tool result content (mark as pruned)
+   */
+  private clearToolResults(message: Message): void {
+    if (typeof message.content !== 'string') {
+      for (const block of message.content) {
+        if (block.type === 'tool_result') {
+          // Mark as pruned (OpenCode style)
+          (block as any).content = '[Old tool result content cleared]';
+          (block as any).pruned = true;
+          (block as any).prunedAt = new Date().toISOString();
+        }
+      }
+    }
+  }
+
+  /**
+   * Format messages for summary prompt
+   */
+  private formatMessagesForSummary(messages: Message[]): string {
+    return messages
+      .map((msg, idx) => {
+        const role = msg.role.toUpperCase();
+        const content =
+          typeof msg.content === 'string'
+            ? msg.content
+            : this.extractTextContent(msg.content);
+        return `[${idx + 1}] ${role}: ${content.slice(0, 500)}`;
+      })
+      .join('\n\n');
+  }
+
+  /**
+   * Extract text content from message content
+   */
+  private extractTextContent(content: string | MessageContent[]): string {
+    if (typeof content === 'string') return content;
+    if (Array.isArray(content)) {
+      return content
+        .filter((c) => c.type === 'text')
+        .map((c) => (c as any).text)
+        .join(' ');
+    }
+    return '';
+  }
+
+  /**
+   * Summarize a tool use
+   */
+  private summarizeToolUse(block: any): string {
+    switch (block.name) {
+      case 'Write':
+      case 'Edit':
+        return `Modified ${block.input.file_path}`;
+      case 'Bash':
+        return `Ran: ${block.input.command?.slice(0, 50)}`;
+      case 'Read':
+        return `Read ${block.input.file_path}`;
+      default:
+        return `Used ${block.name}`;
+    }
+  }
+
+  /**
+   * Extract decision context from content
+   */
+  private extractDecisionContext(content: string): string | null {
+    const sentences = content.split(/[.!?]/);
+    const decisionKeywords = ['decided', 'chose', 'will use', 'going with'];
+
+    const decisionSentence = sentences.find((s) =>
+      decisionKeywords.some((keyword) => s.includes(keyword))
+    );
+
+    return decisionSentence?.trim() || null;
+  }
+
+  /**
+   * Generate unique summary ID
+   */
+  private generateId(): string {
+    return `sum-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+  }
+}

package/src/session/compression/index.ts

@@ -0,0 +1,18 @@
+/**
+ * Session Compression Module
+ *
+ * Implements OpenCode-inspired three-layer compression strategy:
+ * - Layer 1: Tool output pruning (fast, no cost)
+ * - Layer 2: Compaction summarization (LLM-based, medium cost)
+ * - Layer 3: Message filtering (recovery optimization)
+ */
+
+export { CompressionEngine } from './engine.js';
+export type {
+  CompressionConfig,
+  ConversationSummary,
+  ToolUsageSummary,
+  TokenUsage,
+  ModelInfo,
+} from './types.js';
+export { DEFAULT_COMPRESSION_CONFIG } from './types.js';