otherwise-cli 0.1.0

package/src/inference/google.js

@@ -0,0 +1,373 @@
+import { GoogleGenAI } from '@google/genai';
+
+// Retry configuration for transient errors
+const RETRY_CONFIG = {
+  maxRetries: 3,
+  initialDelay: 1000,
+  maxDelay: 10000,
+  retryableErrors: ['RESOURCE_EXHAUSTED', 'UNAVAILABLE', 'DEADLINE_EXCEEDED', 'INTERNAL'],
+};
+
+/**
+ * Check if a model is an image generation model
+ */
+export function isGeminiImageModel(model) {
+  return model.includes('-image') || model === 'gemini-3-pro-image-preview';
+}
+
+/**
+ * Check if a model supports extended thinking/reasoning
+ * @param {string} model - Model identifier
+ * @returns {boolean} - Whether model supports thinking
+ */
+export function isGeminiReasoningModel(model) {
+  // Gemini 2.5 Pro/Flash and Gemini 3 Pro/Flash support thinking, BUT NOT:
+  // - gemini-2.5-flash-image (image generation model)
+  // - gemini-2.5-flash-lite (no reasoning support)
+  // - gemini-3-pro-image-preview (image generation model)
+  const isImageModel = model.includes('-image');
+  const isLiteModel = model.includes('-lite');
+  return !isImageModel && !isLiteModel && (
+    model.includes('2.5-pro') || 
+    model.includes('2.5-flash') || 
+    model.includes('3-pro') || 
+    model.includes('3-flash')
+  );
+}
+
+/**
+ * Sleep helper for retry delays
+ * @param {number} ms - Milliseconds to sleep
+ */
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Check if an error is retryable
+ * @param {Error} error - The error to check
+ * @returns {boolean} - Whether error is retryable
+ */
+function isRetryableError(error) {
+  const message = error.message || '';
+  const code = error.code || error.status || '';
+  
+  // Check for rate limiting
+  if (message.includes('429') || message.includes('rate limit') || message.includes('quota')) {
+    return true;
+  }
+  
+  // Check for known retryable error codes
+  return RETRY_CONFIG.retryableErrors.some(e => 
+    message.includes(e) || String(code).includes(e)
+  );
+}
+
+/**
+ * Normalize image data to base64 string (SDK may return string or Uint8Array)
+ */
+function toBase64(data) {
+  if (typeof data === 'string') return data;
+  if (data instanceof Uint8Array) {
+    return Buffer.from(data).toString('base64');
+  }
+  if (data instanceof ArrayBuffer) {
+    return Buffer.from(new Uint8Array(data)).toString('base64');
+  }
+  if (Buffer.isBuffer(data)) return data.toString('base64');
+  return null;
+}
+
+/**
+ * Get response parts from various possible SDK response shapes
+ */
+function getPartsFromResponse(response) {
+  const c = response.candidates?.[0]?.content;
+  if (c?.parts) return c.parts;
+  if (Array.isArray(c)) return c;
+  const r = response.response?.candidates?.[0]?.content;
+  if (r?.parts) return r.parts;
+  if (Array.isArray(r)) return r;
+  return null;
+}
+
+/**
+ * Extract image blob from a part (camelCase or snake_case, part or nested)
+ */
+function getImageBlobFromPart(part) {
+  const blob = part.inlineData ?? part.inline_data ?? (part.data ? part : null);
+  if (!blob) return null;
+  const data = blob.data;
+  const base64 = toBase64(data);
+  if (!base64) return null;
+  const mimeType = blob.mimeType ?? blob.mime_type ?? part.mimeType ?? part.mime_type ?? 'image/png';
+  return { base64, mimeType };
+}
+
+/**
+ * Generate an image using Gemini image models
+ * Uses responseModalities: ['TEXT', 'IMAGE'] to enable image output
+ * @param {string} model - Model identifier (e.g., 'gemini-2.5-flash-image')
+ * @param {string} prompt - Text prompt for image generation
+ * @param {object} config - Configuration with API keys and settings
+ * @yields {object} - Chunks with type and content (image as base64)
+ */
+export async function* generateGeminiImage(model, prompt, config) {
+  const apiKey = config.apiKeys?.google;
+  if (!apiKey) {
+    throw new Error('Google API key not configured. Run: otherwise config set google <key>');
+  }
+
+  const ai = new GoogleGenAI({ apiKey });
+  yield { type: 'start', model };
+
+  let lastError;
+  for (let attempt = 0; attempt < RETRY_CONFIG.maxRetries; attempt++) {
+    try {
+      const response = await ai.models.generateContent({
+        model,
+        contents: [{ role: 'user', parts: [{ text: prompt }] }],
+        config: {
+          response_modalities: ['TEXT', 'IMAGE'],
+        },
+      });
+
+      console.log('[Gemini image] Response top-level keys:', Object.keys(response || {}));
+      const parts = getPartsFromResponse(response);
+      if (!parts || !parts.length) {
+        console.warn('[Gemini image] No parts in response. Top-level keys:', Object.keys(response || {}));
+        if (response?.candidates?.[0]) {
+          console.warn('[Gemini image] candidates[0] keys:', Object.keys(response.candidates[0]));
+          if (response.candidates[0].content) {
+            console.warn('[Gemini image] content keys:', Object.keys(response.candidates[0].content));
+          }
+        }
+        throw new Error('No content returned from Gemini image generation');
+      }
+      console.log('[Gemini image] Parts count:', parts.length);
+
+      for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        const partKeys = Object.keys(part || {});
+        if (part.text) {
+          yield { type: 'text', content: part.text };
+          continue;
+        }
+        const blob = getImageBlobFromPart(part);
+        if (blob) {
+          console.log('[Gemini image] Yielding image chunk, base64 length:', blob.base64.length);
+          yield {
+            type: 'image',
+            content: blob.base64,
+            mimeType: blob.mimeType,
+          };
+          continue;
+        }
+        if (partKeys.length) {
+          console.warn('[Gemini image] Part', i, 'unknown shape, keys:', partKeys);
+        }
+      }
+      return;
+    } catch (error) {
+      lastError = error;
+      if (attempt < RETRY_CONFIG.maxRetries - 1 && isRetryableError(error)) {
+        const delay = Math.min(
+          RETRY_CONFIG.initialDelay * Math.pow(2, attempt),
+          RETRY_CONFIG.maxDelay
+        );
+        yield { type: 'warning', message: `Request failed, retrying in ${delay}ms...` };
+        await sleep(delay);
+        continue;
+      }
+      throw error;
+    }
+  }
+  throw lastError;
+}
+
+/**
+ * Stream chat completion from Google Gemini
+ * @param {string} model - Model identifier (e.g., 'gemini-2.5-pro')
+ * @param {Array} messages - Array of message objects with role and content
+ * @param {string} systemPrompt - System prompt
+ * @param {object} config - Configuration with API keys and settings
+ * @yields {object} - Chunks with type and content
+ */
+export async function* streamGemini(model, messages, systemPrompt, config) {
+  const apiKey = config.apiKeys?.google;
+  if (!apiKey) {
+    throw new Error('Google API key not configured. Run: otherwise config set google <key>');
+  }
+
+  // Route image models to the image generation function
+  if (isGeminiImageModel(model)) {
+    // For image generation, use the last user message as the prompt
+    const lastUserMessage = [...messages].reverse().find(m => m.role === 'user');
+    const prompt = lastUserMessage?.content || 'Generate an image';
+    yield* generateGeminiImage(model, prompt, config);
+    return;
+  }
+
+  const ai = new GoogleGenAI({ apiKey });
+
+  // Helper: parse data URL to base64 + mimeType for Gemini
+  const parseDataUrl = (dataUrl) => {
+    if (!dataUrl || !dataUrl.startsWith('data:')) return null;
+    const match = dataUrl.match(/^data:(image\/[^;]+);base64,(.+)$/);
+    if (!match) return null;
+    return { mimeType: match[1], data: match[2] };
+  };
+
+  // Convert messages to Gemini format (vision: user messages can have images)
+  const contents = messages.map(m => {
+    const role = m.role === 'assistant' ? 'model' : 'user';
+    if (m.images && m.images.length > 0 && m.role === 'user') {
+      const parts = [];
+      for (const imgDataUrl of m.images) {
+        const parsed = parseDataUrl(imgDataUrl);
+        if (parsed) {
+          parts.push({
+            inlineData: { mimeType: parsed.mimeType, data: parsed.data },
+          });
+        }
+      }
+      parts.push({ text: m.content || '' });
+      return { role, parts };
+    }
+    return { role, parts: [{ text: m.content }] };
+  });
+
+  // Check if this is a reasoning model that supports thoughts
+  const isReasoningModel = isGeminiReasoningModel(model);
+
+  const apiConfig = {
+    systemInstruction: systemPrompt,
+    temperature: config.temperature || 0.7,
+    maxOutputTokens: config.maxTokens || 8192,
+    ...(isReasoningModel && {
+      thinkingConfig: {
+        includeThoughts: true,
+      },
+    }),
+  };
+
+  // Signal that streaming is starting
+  yield { type: 'start', model, isReasoningModel };
+
+  let lastError;
+  for (let attempt = 0; attempt < RETRY_CONFIG.maxRetries; attempt++) {
+    try {
+      const response = await ai.models.generateContentStream({
+        model,
+        contents,
+        config: apiConfig,
+      });
+
+      let totalThinkingChars = 0;
+      let usageMetadata = null;
+      let finishReason = null;
+      
+      // Text buffering for smoother output
+      let textBuffer = '';
+      let lastFlush = Date.now();
+      const FLUSH_INTERVAL = 50; // ms - flush buffer every 50ms or on newlines
+      const MIN_BUFFER_SIZE = 3; // Minimum chars before considering flush
+
+      for await (const chunk of response) {
+        if (chunk.candidates?.[0]?.content?.parts) {
+          for (const part of chunk.candidates[0].content.parts) {
+            if (part.text) {
+              if (part.thought && isReasoningModel) {
+                // This is thinking/reasoning content - stream immediately for responsiveness
+                totalThinkingChars += part.text.length;
+                yield { type: 'thinking', content: part.text, totalChars: totalThinkingChars };
+              } else {
+                // Regular response content - buffer for smoother output
+                textBuffer += part.text;
+                const now = Date.now();
+                const timeSinceFlush = now - lastFlush;
+                
+                // Flush buffer if:
+                // 1. Contains a newline (natural break point)
+                // 2. Enough time has passed and buffer has content
+                // 3. Buffer is getting large
+                const shouldFlush = 
+                  textBuffer.includes('\n') ||
+                  (timeSinceFlush >= FLUSH_INTERVAL && textBuffer.length >= MIN_BUFFER_SIZE) ||
+                  textBuffer.length > 100;
+                
+                if (shouldFlush && textBuffer.length > 0) {
+                  yield { type: 'text', content: textBuffer };
+                  textBuffer = '';
+                  lastFlush = now;
+                }
+              }
+            }
+          }
+        }
+        
+        // Capture finish reason from candidates
+        if (chunk.candidates?.[0]?.finishReason) {
+          finishReason = chunk.candidates[0].finishReason;
+        }
+        
+        // Capture usage metadata (available on chunks, last one has final counts)
+        if (chunk.usageMetadata) {
+          usageMetadata = chunk.usageMetadata;
+        }
+      }
+
+      // Flush any remaining buffered text
+      if (textBuffer.length > 0) {
+        yield { type: 'text', content: textBuffer };
+      }
+
+      // Yield usage stats at the end
+      if (usageMetadata) {
+        yield {
+          type: 'usage',
+          inputTokens: usageMetadata.promptTokenCount || 0,
+          outputTokens: usageMetadata.candidatesTokenCount || 0,
+          totalTokens: usageMetadata.totalTokenCount || 0,
+          thinkingTokens: usageMetadata.thoughtsTokenCount || 0,
+          finishReason: finishReason || 'STOP',
+          model,
+        };
+      }
+
+      return; // Success - exit retry loop
+
+    } catch (error) {
+      lastError = error;
+      
+      // Check if we should retry
+      if (attempt < RETRY_CONFIG.maxRetries - 1 && isRetryableError(error)) {
+        const delay = Math.min(
+          RETRY_CONFIG.initialDelay * Math.pow(2, attempt),
+          RETRY_CONFIG.maxDelay
+        );
+        yield { type: 'warning', message: `Request failed, retrying in ${delay}ms...` };
+        await sleep(delay);
+        continue;
+      }
+      
+      // Enhance error message for common issues
+      let enhancedMessage = error.message;
+      if (error.message.includes('API key')) {
+        enhancedMessage = 'Invalid Google API key. Run: otherwise config set google <your-key>';
+      } else if (error.message.includes('quota') || error.message.includes('429')) {
+        enhancedMessage = 'Rate limit exceeded. Please wait a moment and try again.';
+      } else if (error.message.includes('not found') || error.message.includes('404')) {
+        enhancedMessage = `Model "${model}" not found. Check available models with: otherwise models`;
+      }
+      
+      const enhancedError = new Error(enhancedMessage);
+      enhancedError.originalError = error;
+      throw enhancedError;
+    }
+  }
+  
+  throw lastError;
+}
+
+export default { streamGemini, generateGeminiImage, isGeminiImageModel, isGeminiReasoningModel };

package/src/inference/index.js

@@ -0,0 +1,81 @@
+import { streamClaude } from './anthropic.js';
+import { streamOpenAI, isOpenAIImageModel } from './openai.js';
+import { streamGemini, isGeminiImageModel } from './google.js';
+import { streamGrok, isGrokImageModel } from './xai.js';
+import { streamOllama } from './ollama.js';
+import { streamOpenRouter, isOpenRouterImageModel, fetchOpenRouterModels } from './openrouter.js';
+
+/**
+ * Check if a model is an image generation model
+ * Image models require special handling (different endpoints, no streaming, etc.)
+ */
+export function isImageModel(model) {
+  if (model.startsWith('gpt') || model.startsWith('dall-e')) {
+    return isOpenAIImageModel(model);
+  }
+  if (model.startsWith('gemini')) {
+    return isGeminiImageModel(model);
+  }
+  if (model.startsWith('grok')) {
+    return isGrokImageModel(model);
+  }
+  if (model.startsWith('openrouter:')) {
+    return isOpenRouterImageModel(model);
+  }
+  return false;
+}
+
+/**
+ * Route to the appropriate inference provider based on model name
+ * @param {string} model - Model identifier
+ * @param {Array} messages - Conversation messages
+ * @param {string} systemPrompt - System prompt
+ * @param {object} config - Configuration with API keys
+ * @returns {AsyncGenerator} - Yields chunks of response
+ */
+export async function* streamInference(model, messages, systemPrompt, config) {
+  // Determine provider from model name
+  if (model.startsWith('openrouter:')) {
+    yield* streamOpenRouter(model, messages, systemPrompt, config);
+  } else if (model.startsWith('claude')) {
+    yield* streamClaude(model, messages, systemPrompt, config);
+  } else if (model.startsWith('gpt') || model.startsWith('o1') || model.startsWith('o3') || model.startsWith('dall-e')) {
+    yield* streamOpenAI(model, messages, systemPrompt, config);
+  } else if (model.startsWith('gemini')) {
+    yield* streamGemini(model, messages, systemPrompt, config);
+  } else if (model.startsWith('grok')) {
+    yield* streamGrok(model, messages, systemPrompt, config);
+  } else if (model.startsWith('ollama:')) {
+    yield* streamOllama(model.replace('ollama:', ''), messages, systemPrompt, config);
+  } else {
+    // Default to Claude if unknown
+    yield* streamClaude(model, messages, systemPrompt, config);
+  }
+}
+
+/**
+ * Get provider name from model
+ */
+export function getProviderFromModel(model) {
+  if (model.startsWith('openrouter:')) return 'openrouter';
+  if (model.startsWith('claude')) return 'anthropic';
+  if (model.startsWith('gpt') || model.startsWith('o1') || model.startsWith('o3') || model.startsWith('dall-e')) return 'openai';
+  if (model.startsWith('gemini')) return 'google';
+  if (model.startsWith('grok')) return 'xai';
+  if (model.startsWith('ollama:')) return 'ollama';
+  return 'anthropic';
+}
+
+/**
+ * Check if required API key is configured for a model
+ */
+export function hasRequiredApiKey(model, config) {
+  const provider = getProviderFromModel(model);
+  if (provider === 'ollama') return true; // Ollama doesn't need API key
+  return !!config.apiKeys?.[provider];
+}
+
+// Re-export OpenRouter model fetching for use in server
+export { fetchOpenRouterModels } from './openrouter.js';
+
+export default { streamInference, getProviderFromModel, hasRequiredApiKey, isImageModel, fetchOpenRouterModels };