otherwise-cli 0.1.0

package/src/inference/openrouter.js

@@ -0,0 +1,378 @@
+import OpenAI from 'openai';
+
+// Cache for OpenRouter models (refreshed every 5 minutes)
+let modelsCache = null;
+let modelsCacheTime = 0;
+const CACHE_TTL = 5 * 60 * 1000; // 5 minutes
+
+/**
+ * Fetch all available models from OpenRouter
+ * @param {string} apiKey - OpenRouter API key
+ * @returns {Promise<Array>} Array of model objects
+ */
+export async function fetchOpenRouterModels(apiKey) {
+  // Return cached models if still valid
+  if (modelsCache && Date.now() - modelsCacheTime < CACHE_TTL) {
+    return modelsCache;
+  }
+
+  try {
+    const response = await fetch('https://openrouter.ai/api/v1/models', {
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+        'HTTP-Referer': 'https://otherwise.dev',
+        'X-Title': 'Otherwise AI',
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to fetch models: ${response.status}`);
+    }
+
+    const data = await response.json();
+    
+    // Transform models to a consistent format
+    const models = (data.data || []).map(model => ({
+      id: `openrouter:${model.id}`,
+      name: model.name || model.id,
+      provider: 'OpenRouter',
+      contextLength: model.context_length || 4096,
+      maxTokens: model.top_provider?.max_completion_tokens || model.context_length || 4096,
+      pricing: {
+        prompt: model.pricing?.prompt || 0,
+        completion: model.pricing?.completion || 0,
+        image: model.pricing?.image || 0,
+      },
+      // Determine model capabilities from modality
+      type: getModelType(model),
+      // Store raw model data for reference
+      _raw: model,
+    }));
+
+    // Update cache
+    modelsCache = models;
+    modelsCacheTime = Date.now();
+
+    return models;
+  } catch (error) {
+    console.error('[OpenRouter] Failed to fetch models:', error);
+    // Return cached models if available, otherwise empty array
+    return modelsCache || [];
+  }
+}
+
+/**
+ * Determine model type/capabilities from OpenRouter model data
+ * @param {object} model - OpenRouter model object
+ * @returns {Array<string>} Array of type tags
+ */
+function getModelType(model) {
+  const types = [];
+  
+  const arch = model.architecture || {};
+  const inputModality = arch.input_modalities || arch.modality?.split('+') || [];
+  const outputModality = arch.output_modalities || [];
+  
+  // Check for image input support
+  if (inputModality.includes('image')) {
+    types.push('image-input');
+  }
+  
+  // Check for image output support
+  if (outputModality.includes('image')) {
+    types.push('image-output');
+  }
+  
+  // Check for reasoning support based on model name patterns
+  const modelId = model.id.toLowerCase();
+  if (modelId.includes('reasoning') || 
+      modelId.includes('think') ||
+      modelId.includes('o1') ||
+      modelId.includes('o3') ||
+      modelId.includes('deepseek-r1') ||
+      modelId.includes('qwq')) {
+    types.push('reasoning');
+  }
+  
+  return types;
+}
+
+/**
+ * Check if a model is an image generation model
+ * @param {string} model - Model identifier
+ * @returns {boolean}
+ */
+export function isOpenRouterImageModel(model) {
+  const modelId = model.replace('openrouter:', '').toLowerCase();
+  // Common image generation model patterns
+  return modelId.includes('dall-e') ||
+         modelId.includes('stable-diffusion') ||
+         modelId.includes('midjourney') ||
+         modelId.includes('imagen') ||
+         modelId.includes('flux');
+}
+
+/**
+ * Check if a model supports reasoning/thinking content
+ * @param {string} model - Model identifier
+ * @returns {boolean}
+ */
+export function isOpenRouterReasoningModel(model) {
+  const modelId = model.replace('openrouter:', '').toLowerCase();
+  return modelId.includes('reasoning') ||
+         modelId.includes('think') ||
+         modelId.includes('/o1') ||
+         modelId.includes('/o3') ||
+         modelId.includes('deepseek-r1') ||
+         modelId.includes('qwq');
+}
+
+/**
+ * Stream chat completion from OpenRouter
+ * Uses OpenAI-compatible API
+ * @param {string} model - Model identifier (with openrouter: prefix)
+ * @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* streamOpenRouter(model, messages, systemPrompt, config) {
+  const apiKey = config.apiKeys?.openrouter;
+  if (!apiKey) {
+    throw new Error('OpenRouter API key not configured. Run: otherwise config set openrouter <key>');
+  }
+
+  // Strip the openrouter: prefix to get the actual model ID
+  const actualModel = model.replace('openrouter:', '');
+  
+  // Check for image models (would need different handling)
+  if (isOpenRouterImageModel(model)) {
+    // OpenRouter image generation goes through different models
+    // Most image models on OpenRouter work through chat completions
+    // returning image URLs or base64 in the response
+    yield* streamOpenRouterImage(actualModel, messages, config);
+    return;
+  }
+
+  const client = new OpenAI({
+    apiKey,
+    baseURL: 'https://openrouter.ai/api/v1',
+    defaultHeaders: {
+      'HTTP-Referer': 'https://otherwise.dev',
+      'X-Title': 'Otherwise AI',
+    },
+    timeout: 300000, // 5 minute timeout for long-running models
+  });
+
+  // Convert messages to OpenAI format, handling multimodal content
+  const openrouterMessages = [
+    { role: 'system', content: systemPrompt },
+    ...messages.map(m => {
+      const role = m.role === 'user' ? 'user' : 'assistant';
+      
+      // Handle messages with images (multimodal)
+      if (m.images && m.images.length > 0 && m.role === 'user') {
+        const content = [];
+        
+        // Add images first
+        for (const imgDataUrl of m.images) {
+          // Check if it's a data URL or regular URL
+          if (imgDataUrl.startsWith('data:')) {
+            content.push({
+              type: 'image_url',
+              image_url: { url: imgDataUrl },
+            });
+          } else {
+            content.push({
+              type: 'image_url',
+              image_url: { url: imgDataUrl },
+            });
+          }
+        }
+        
+        // Add text content
+        content.push({ type: 'text', text: m.content || '' });
+        
+        return { role, content };
+      }
+      
+      // Regular text message
+      return { role, content: m.content };
+    }),
+  ];
+
+  // Check if this is a reasoning model
+  const isReasoningModel = isOpenRouterReasoningModel(model);
+
+  // Build request options
+  const requestOptions = {
+    model: actualModel,
+    messages: openrouterMessages,
+    max_tokens: config.maxTokens || 8192,
+    stream: true,
+  };
+
+  // Only add temperature for non-reasoning models (reasoning models often don't support it)
+  if (!isReasoningModel) {
+    requestOptions.temperature = config.temperature || 0.7;
+  }
+
+  try {
+    const stream = await client.chat.completions.create(requestOptions);
+
+    let usage = null;
+
+    for await (const chunk of stream) {
+      const delta = chunk.choices?.[0]?.delta;
+      
+      // Handle reasoning content if available (some models return this)
+      if (delta?.reasoning_content) {
+        yield { type: 'thinking', content: delta.reasoning_content };
+      }
+      
+      // Handle regular content
+      if (delta?.content) {
+        yield { type: 'text', content: delta.content };
+      }
+
+      // Capture usage from final chunk (OpenRouter includes this with streaming)
+      if (chunk.usage) {
+        usage = chunk.usage;
+      }
+    }
+
+    // Yield usage stats at the end
+    if (usage) {
+      yield {
+        type: 'usage',
+        inputTokens: usage.prompt_tokens || 0,
+        outputTokens: usage.completion_tokens || 0,
+        totalTokens: usage.total_tokens || 0,
+      };
+    }
+  } catch (error) {
+    // Enhance error messages
+    let enhancedMessage = error.message;
+    
+    if (error.message?.includes('401') || error.message?.includes('Unauthorized')) {
+      enhancedMessage = 'Invalid OpenRouter API key. Check your key at https://openrouter.ai/keys';
+    } else if (error.message?.includes('402') || error.message?.includes('insufficient')) {
+      enhancedMessage = 'Insufficient OpenRouter credits. Add credits at https://openrouter.ai/credits';
+    } else if (error.message?.includes('429')) {
+      enhancedMessage = 'OpenRouter rate limit exceeded. Please wait and try again.';
+    } else if (error.message?.includes('model') && error.message?.includes('not found')) {
+      enhancedMessage = `Model "${actualModel}" not available on OpenRouter. Check available models at https://openrouter.ai/models`;
+    }
+    
+    const enhancedError = new Error(enhancedMessage);
+    enhancedError.originalError = error;
+    throw enhancedError;
+  }
+}
+
+/**
+ * Handle image generation through OpenRouter
+ * Most image models on OpenRouter work through chat API
+ * @param {string} model - Model identifier (without prefix)
+ * @param {Array} messages - Messages array
+ * @param {object} config - Configuration
+ * @yields {object} - Chunks with type and content
+ */
+async function* streamOpenRouterImage(model, messages, config) {
+  const apiKey = config.apiKeys?.openrouter;
+  
+  const client = new OpenAI({
+    apiKey,
+    baseURL: 'https://openrouter.ai/api/v1',
+    defaultHeaders: {
+      'HTTP-Referer': 'https://otherwise.dev',
+      'X-Title': 'Otherwise AI',
+    },
+    timeout: 120000, // 2 minute timeout for image generation
+  });
+
+  // Get the last user message as the prompt
+  const lastUserMessage = [...messages].reverse().find(m => m.role === 'user');
+  const prompt = lastUserMessage?.content || 'Generate an image';
+
+  try {
+    // For DALL-E models through OpenRouter, use the images endpoint
+    if (model.includes('dall-e')) {
+      const response = await client.images.generate({
+        model,
+        prompt,
+        n: 1,
+        response_format: 'b64_json',
+      });
+
+      const imageData = response.data?.[0];
+      
+      if (imageData?.b64_json) {
+        yield { type: 'text', content: 'Here\'s the generated image:\n\n' };
+        yield {
+          type: 'image',
+          content: imageData.b64_json,
+          mimeType: 'image/png',
+          revisedPrompt: imageData.revised_prompt || prompt,
+        };
+      } else if (imageData?.url) {
+        yield { type: 'text', content: 'Here\'s the generated image:\n\n' };
+        yield {
+          type: 'image_url',
+          content: imageData.url,
+          revisedPrompt: imageData.revised_prompt || prompt,
+        };
+      }
+    } else {
+      // For other image models, try chat completions (some return images this way)
+      const response = await client.chat.completions.create({
+        model,
+        messages: [
+          { role: 'system', content: 'You are an image generation assistant.' },
+          { role: 'user', content: prompt },
+        ],
+        max_tokens: 4096,
+      });
+
+      const content = response.choices?.[0]?.message?.content || '';
+      
+      // Check if response contains image data or URL
+      if (content.includes('data:image')) {
+        // Extract base64 image
+        const match = content.match(/data:image\/[^;]+;base64,[^"'\s]+/);
+        if (match) {
+          yield { type: 'text', content: 'Here\'s the generated image:\n\n' };
+          yield {
+            type: 'image',
+            content: match[0].split(',')[1],
+            mimeType: match[0].split(';')[0].replace('data:', ''),
+          };
+        } else {
+          yield { type: 'text', content };
+        }
+      } else {
+        // Return as text (might be a description or URL)
+        yield { type: 'text', content };
+      }
+    }
+  } catch (error) {
+    console.error('[OpenRouter Image] Generation error:', error);
+    throw error;
+  }
+}
+
+/**
+ * Clear the models cache (useful for forcing a refresh)
+ */
+export function clearOpenRouterModelsCache() {
+  modelsCache = null;
+  modelsCacheTime = 0;
+}
+
+export default { 
+  streamOpenRouter, 
+  fetchOpenRouterModels, 
+  isOpenRouterImageModel,
+  isOpenRouterReasoningModel,
+  clearOpenRouterModelsCache,
+};

package/src/inference/xai.js

@@ -0,0 +1,200 @@
+import OpenAI from 'openai';
+
+/**
+ * Check if a model supports reasoning content
+ * According to XAI docs: grok-3-mini returns reasoning_content
+ * grok-3, grok-4, grok-4-fast-reasoning use encrypted reasoning (not directly accessible)
+ */
+function supportsReasoningContent(model) {
+  return model === 'grok-3-mini';
+}
+
+/**
+ * Check if a model is a reasoning model (for request configuration)
+ */
+function isReasoningModel(model) {
+  return model.includes('reasoning') || 
+         model === 'grok-3-mini' || 
+         model === 'grok-3' || 
+         model === 'grok-4';
+}
+
+/**
+ * Check if a model is an image generation model
+ */
+export function isGrokImageModel(model) {
+  return model === 'grok-2-image';
+}
+
+/**
+ * Generate an image using xAI Grok image model
+ * Uses the /v1/images/generations endpoint (NOT chat completions)
+ * @param {string} model - Model identifier (e.g., 'grok-2-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* generateGrokImage(model, prompt, config) {
+  const apiKey = config.apiKeys?.xai;
+  if (!apiKey) {
+    throw new Error('xAI API key not configured. Run: otherwise config set xai <key>');
+  }
+
+  console.log('[xAI Image] Starting image generation with model:', model);
+  console.log('[xAI Image] Prompt:', prompt.substring(0, 100) + '...');
+
+  const client = new OpenAI({
+    apiKey,
+    baseURL: 'https://api.x.ai/v1',
+    timeout: 120000, // 2 minute timeout for image generation
+  });
+
+  try {
+    // Use the images.generate endpoint for image models
+    console.log('[xAI Image] Calling images.generate endpoint...');
+    const response = await client.images.generate({
+      model,
+      prompt,
+      n: 1,
+      response_format: 'b64_json', // Get base64 data directly
+    });
+
+    console.log('[xAI Image] Response received');
+    console.log('[xAI Image] Data array length:', response.data?.length);
+
+    // Extract the image data
+    const imageData = response.data?.[0];
+    
+    if (imageData?.b64_json) {
+      console.log('[xAI Image] Got b64_json, length:', imageData.b64_json.length);
+      // Yield a brief text response
+      yield { type: 'text', content: 'Here\'s the generated image:\n\n' };
+      
+      // Yield the image as base64
+      yield { 
+        type: 'image', 
+        content: imageData.b64_json,
+        mimeType: 'image/jpeg', // Grok generates JPG format
+        revisedPrompt: imageData.revised_prompt || prompt,
+      };
+    } else if (imageData?.url) {
+      console.log('[xAI Image] Got URL:', imageData.url.substring(0, 50));
+      // Fallback to URL if b64_json not available
+      yield { type: 'text', content: 'Here\'s the generated image:\n\n' };
+      yield { 
+        type: 'image_url', 
+        content: imageData.url,
+        revisedPrompt: imageData.revised_prompt || prompt,
+      };
+    } else {
+      console.error('[xAI Image] No image data in response:', JSON.stringify(response).substring(0, 500));
+      throw new Error('No image data returned from xAI');
+    }
+  } catch (error) {
+    console.error('[xAI Image] Generation error:', error);
+    throw error;
+  }
+}
+
+/**
+ * Stream chat completion from xAI Grok (uses OpenAI-compatible API)
+ * @param {string} model - Model identifier (e.g., 'grok-4-fast-reasoning')
+ * @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* streamGrok(model, messages, systemPrompt, config) {
+  const apiKey = config.apiKeys?.xai;
+  if (!apiKey) {
+    throw new Error('xAI API key not configured. Run: otherwise config set xai <key>');
+  }
+
+  // Route image models to the image generation function
+  if (isGrokImageModel(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* generateGrokImage(model, prompt, config);
+    return;
+  }
+
+  const client = new OpenAI({
+    apiKey,
+    baseURL: 'https://api.x.ai/v1',
+    timeout: 360000, // 6 minute timeout for reasoning models
+  });
+
+  // Convert messages to OpenAI format (xAI uses same format; vision: user messages can have images)
+  const xaiMessages = [
+    { role: 'system', content: systemPrompt },
+    ...messages.map(m => {
+      const role = m.role === 'user' ? 'user' : 'assistant';
+      if (m.images && m.images.length > 0 && m.role === 'user') {
+        const imageBlocks = m.images.map((imgDataUrl) => ({
+          type: 'image_url',
+          image_url: { url: imgDataUrl },
+        }));
+        return {
+          role,
+          content: [...imageBlocks, { type: 'text', text: m.content || '' }],
+        };
+      }
+      return { role, content: m.content };
+    }),
+  ];
+
+  // Build request options
+  const requestOptions = {
+    model,
+    messages: xaiMessages,
+    max_completion_tokens: config.maxTokens || 8192,
+    stream: true,
+    stream_options: { include_usage: true }, // Get real token counts
+  };
+
+  // Only add temperature for non-reasoning models (reasoning models don't support it per docs)
+  if (!isReasoningModel(model)) {
+    requestOptions.temperature = config.temperature || 0.7;
+  }
+
+  // For grok-3-mini, add reasoning_effort if desired
+  if (model === 'grok-3-mini') {
+    requestOptions.reasoning_effort = config.reasoningEffort || 'high';
+  }
+
+  const stream = await client.chat.completions.create(requestOptions);
+
+  let usage = null;
+
+  for await (const chunk of stream) {
+    const delta = chunk.choices?.[0]?.delta;
+    
+    // Handle reasoning content (grok-3-mini returns this)
+    if (supportsReasoningContent(model) && delta?.reasoning_content) {
+      yield { type: 'thinking', content: delta.reasoning_content };
+    }
+    
+    // Handle regular content
+    if (delta?.content) {
+      yield { type: 'text', content: delta.content };
+    }
+
+    // Capture usage from final chunk
+    if (chunk.usage) {
+      usage = chunk.usage;
+    }
+  }
+
+  // Yield usage stats at the end
+  if (usage) {
+    yield {
+      type: 'usage',
+      inputTokens: usage.prompt_tokens || 0,
+      outputTokens: usage.completion_tokens || 0,
+      totalTokens: usage.total_tokens || 0,
+    };
+  }
+}
+
+export default { streamGrok, generateGrokImage, isGrokImageModel };

package/src/logBridge.js

@@ -0,0 +1,9 @@
+/**
+ * Log bridge: allows the server to receive log lines from anywhere in the process
+ * (e.g. console.log from tools.js). The server sets logSink.write to broadcast to WebSocket clients.
+ */
+export const logSink = {
+  write(_level, _args) {
+    // No-op by default; server.js assigns a function that broadcasts to connected clients
+  },
+};