otherwise-cli 0.1.0

package/src/inference/ollama.js

@@ -0,0 +1,383 @@
+import { TOOLS } from "../agent/tools.js";
+
+/**
+ * Check if a model is a reasoning/thinking model that supports the think parameter
+ * @param {string} model - Model name (e.g., 'deepseek-r1', 'qwq', 'gpt-oss')
+ * @returns {boolean} - Whether model supports thinking
+ */
+export function isOllamaReasoningModel(model) {
+  const modelLower = model.toLowerCase();
+
+  // Explicit exclusions - models that have "qwen3" but don't support thinking
+  // These are typically coding/specialized variants
+  if (modelLower.includes("coder") || modelLower.includes("code")) {
+    return false;
+  }
+
+  return (
+    modelLower.includes("deepseek-r1") ||
+    modelLower.includes("deepseek-v3") ||
+    modelLower.includes("qwq") ||
+    // Only match base qwen3 models, not specialized variants like coder
+    // The base qwen3 models (qwen3:8b, qwen3:32b) support thinking
+    (modelLower.includes("qwen3") && !modelLower.includes("-")) ||
+    modelLower.includes("gpt-oss") ||
+    modelLower.includes("thinking") ||
+    modelLower.includes("reason")
+  );
+}
+
+/**
+ * Map our parameter types to Ollama-supported JSON Schema types.
+ * Ollama expects: string, integer, boolean. "number" and "array" can cause
+ * "expected element type <function> but have <parameter>" from schema validation.
+ */
+function ollamaParamType(paramSpec) {
+  const t = (paramSpec.type || "string").toLowerCase();
+  if (t === "integer" || t === "boolean" || t === "string") return t;
+  if (t === "number") return "integer";
+  // array/object: describe as string so the model passes JSON; avoids schema errors
+  if (t === "array" || t === "object") return "string";
+  return "string";
+}
+
+/**
+ * Convert our TOOLS format to Ollama's tool format.
+ * Uses only Ollama-supported types (string, integer, boolean) to avoid
+ * "expected element type <function> but have <parameter>" errors.
+ * @returns {Array} - Array of tools in Ollama format
+ */
+function getOllamaTools() {
+  return Object.entries(TOOLS).map(([name, tool]) => {
+    const properties = {};
+    const required = [];
+    const rawType = (spec) => (spec.type || "string").toLowerCase();
+
+    for (const [paramName, paramSpec] of Object.entries(
+      tool.parameters || {},
+    )) {
+      const type = ollamaParamType(paramSpec);
+      let description = paramSpec.description || "";
+      if (rawType(paramSpec) === "array") {
+        description =
+          (description ? description + ". " : "") + "Pass a JSON array string.";
+      }
+      properties[paramName] = {
+        type,
+        description: description.trim() || "Parameter value",
+      };
+      if (paramSpec.required) {
+        required.push(paramName);
+      }
+    }
+
+    return {
+      type: "function",
+      function: {
+        name,
+        description: tool.description,
+        parameters: {
+          type: "object",
+          properties,
+          required,
+        },
+      },
+    };
+  });
+}
+
+/**
+ * Convert a native tool call to XML format for the agent
+ * @param {object} toolCall - Ollama tool call object
+ * @returns {string} - XML formatted tool call
+ */
+function toolCallToXml(toolCall) {
+  const name = toolCall.function?.name || toolCall.name;
+  const args = toolCall.function?.arguments || toolCall.arguments || {};
+
+  let xml = `<tool_call>\n<name>${name}</name>\n`;
+
+  for (const [key, value] of Object.entries(args)) {
+    if (value === null || value === undefined) continue;
+
+    // For content/code that might have special chars, we just include it raw
+    // The agent's XML parser handles this
+    const strValue =
+      typeof value === "object" ? JSON.stringify(value) : String(value);
+    xml += `<${key}>${strValue}</${key}>\n`;
+  }
+
+  xml += `</tool_call>`;
+  return xml;
+}
+
+/**
+ * Stream chat completion from local Ollama server
+ * Supports reasoning/thinking models with separate thinking tokens
+ * Also supports native tool calling for models that support it
+ * @param {string} model - Model name (e.g., 'llama3', 'deepseek-r1', 'gpt-oss')
+ * @param {Array} messages - Array of message objects with role and content
+ * @param {string} systemPrompt - System prompt
+ * @param {object} config - Configuration with settings
+ * @yields {object} - Chunks with type and content (including thinking tokens for reasoning models)
+ */
+export async function* streamOllama(model, messages, systemPrompt, config) {
+  const baseUrl = config.ollamaUrl || "http://localhost:11434";
+
+  // Check if this is a reasoning model that supports thinking
+  let isReasoningModel = isOllamaReasoningModel(model);
+
+  // Helper: extract base64 from data URL for Ollama (expects raw base64 strings)
+  const toOllamaImages = (images) => {
+    if (!images?.length) return undefined;
+    return images
+      .map((img) => {
+        if (typeof img !== "string") return null;
+        const match = img.match(/^data:image\/[^;]+;base64,(.+)$/);
+        return match ? match[1] : img;
+      })
+      .filter(Boolean);
+  };
+
+  // Convert messages to Ollama format (vision: user messages can have images)
+  const ollamaMessages = [
+    { role: "system", content: systemPrompt },
+    ...messages.map((m) => {
+      const role = m.role === "user" ? "user" : "assistant";
+      const base = { role, content: m.content };
+      const imgList = toOllamaImages(m.images);
+      if (imgList?.length) {
+        base.images = imgList;
+      }
+      return base;
+    }),
+  ];
+
+  // Get tools in Ollama format (unless explicitly disabled, e.g. during recovery)
+  const tools = config.disableTools ? undefined : getOllamaTools();
+
+  // Build request body - add think: true for reasoning models
+  const requestBody = {
+    model,
+    messages: ollamaMessages,
+    stream: true,
+    ...(tools ? { tools } : {}),
+    options: {
+      num_predict: config.maxTokens || 8192,
+      temperature: config.temperature || 0.7,
+    },
+  };
+
+  // Enable thinking for reasoning models (Ollama's native thinking support)
+  if (isReasoningModel) {
+    requestBody.think = true;
+  }
+
+  let response = await fetch(`${baseUrl}/api/chat`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(requestBody),
+  });
+
+  // Handle "does not support tools" and "does not support thinking" by retrying without those params
+  if (!response.ok) {
+    let errorText = await response.text();
+
+    // Retry without tools if model doesn't support tool calling (e.g. gemma3)
+    if (errorText.includes("does not support tools") && requestBody.tools) {
+      console.warn(
+        `[Ollama] Model ${model} does not support tools, retrying without tools`,
+      );
+      delete requestBody.tools;
+      response = await fetch(`${baseUrl}/api/chat`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(requestBody),
+      });
+      if (!response.ok) errorText = await response.text();
+    }
+
+    // Retry without think if model doesn't support thinking
+    if (
+      !response.ok &&
+      errorText.includes("does not support thinking") &&
+      requestBody.think
+    ) {
+      console.warn(
+        `[Ollama] Model ${model} does not support thinking, retrying without think parameter`,
+      );
+      delete requestBody.think;
+      isReasoningModel = false;
+      response = await fetch(`${baseUrl}/api/chat`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(requestBody),
+      });
+      if (!response.ok) errorText = await response.text();
+    }
+
+    if (!response.ok) {
+      throw new Error(`Ollama error: ${errorText}`);
+    }
+  }
+
+  // Signal that streaming is starting (include reasoning model info)
+  yield { type: "start", model, isReasoningModel };
+
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let totalThinkingChars = 0;
+  let hasContent = false;
+  let pendingToolCalls = []; // Collect tool calls for end of stream
+  // Ollama /api/chat streams cumulative message.content (and message.thinking); emit only deltas
+  let lastTextContent = "";
+  let lastThinkingContent = "";
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+
+    const chunk = decoder.decode(value, { stream: true });
+    const lines = chunk.split("\n").filter((line) => line.trim());
+
+    for (const line of lines) {
+      try {
+        const data = JSON.parse(line);
+
+        // Handle thinking tokens (reasoning models with think: true)
+        // Ollama returns cumulative message.thinking; emit only the new part
+        if (data.message?.thinking) {
+          const full = data.message.thinking;
+          const delta = full.startsWith(lastThinkingContent)
+            ? full.slice(lastThinkingContent.length)
+            : full;
+          lastThinkingContent = full;
+          totalThinkingChars += delta.length;
+          if (delta) {
+            yield {
+              type: "thinking",
+              content: delta,
+              totalChars: totalThinkingChars,
+            };
+          }
+        }
+
+        // Handle regular content: Ollama sends cumulative message.content; yield only the new part
+        if (data.message?.content) {
+          hasContent = true;
+          const full = data.message.content;
+          const delta = full.startsWith(lastTextContent)
+            ? full.slice(lastTextContent.length)
+            : full;
+          lastTextContent = full;
+          if (delta) {
+            yield { type: "text", content: delta };
+          }
+        }
+
+        // Handle native tool calls from Ollama
+        // Tool calls come in message.tool_calls array
+        if (
+          data.message?.tool_calls &&
+          Array.isArray(data.message.tool_calls)
+        ) {
+          for (const toolCall of data.message.tool_calls) {
+            pendingToolCalls.push(toolCall);
+          }
+        }
+
+        if (data.done) {
+          // If we have tool calls, convert them to XML and yield as text
+          // This allows the existing agent loop to handle them
+          if (pendingToolCalls.length > 0) {
+            console.log(
+              `[Ollama] Converting ${pendingToolCalls.length} native tool call(s) to XML format`,
+            );
+            for (const toolCall of pendingToolCalls) {
+              const xmlToolCall = toolCallToXml(toolCall);
+              yield { type: "text", content: xmlToolCall };
+              hasContent = true;
+            }
+          }
+
+          // If reasoning model produced thinking but no content or tool calls,
+          // yield a special marker so the agent can handle recovery
+          if (
+            isReasoningModel &&
+            totalThinkingChars > 0 &&
+            !hasContent &&
+            pendingToolCalls.length === 0
+          ) {
+            console.warn(
+              `[Ollama] Reasoning model produced ${totalThinkingChars} thinking chars but no content or tool calls.`,
+            );
+            // Yield a marker that the agent can use to trigger recovery
+            // Don't yield text - the agent will handle prompting the model
+            yield {
+              type: "thinking_only",
+              thinkingChars: totalThinkingChars,
+              message: "Model produced reasoning but no response or tool calls",
+            };
+          }
+
+          // Ollama provides token counts when done
+          // eval_count = output tokens, prompt_eval_count = input tokens
+          yield {
+            type: "usage",
+            inputTokens: data.prompt_eval_count || 0,
+            outputTokens: data.eval_count || 0,
+            totalTokens: (data.prompt_eval_count || 0) + (data.eval_count || 0),
+            thinkingChars: totalThinkingChars,
+          };
+          return;
+        }
+      } catch (e) {
+        // Skip malformed JSON lines
+      }
+    }
+  }
+}
+
+/**
+ * Check if Ollama is available
+ */
+export async function checkOllamaAvailable(config) {
+  const baseUrl = config.ollamaUrl || "http://localhost:11434";
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 2000);
+    const response = await fetch(`${baseUrl}/api/tags`, {
+      signal: controller.signal,
+    });
+    clearTimeout(timeout);
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * List available Ollama models
+ */
+export async function listOllamaModels(config) {
+  const baseUrl = config.ollamaUrl || "http://localhost:11434";
+  try {
+    const response = await fetch(`${baseUrl}/api/tags`);
+    if (!response.ok) return [];
+    const data = await response.json();
+    return (data.models || []).map((m) => ({
+      id: `ollama:${m.name}`,
+      name: m.name,
+      size: m.size,
+    }));
+  } catch {
+    return [];
+  }
+}
+
+export default {
+  streamOllama,
+  checkOllamaAvailable,
+  listOllamaModels,
+  isOllamaReasoningModel,
+};

package/src/inference/openai.js

@@ -0,0 +1,140 @@
+import OpenAI from 'openai';
+
+/**
+ * Check if a model is an image generation model
+ */
+export function isOpenAIImageModel(model) {
+  return model === 'gpt-image-1' || model.startsWith('dall-e');
+}
+
+/**
+ * Generate an image using OpenAI image models (gpt-image-1, dall-e-3)
+ * @param {string} model - Model identifier (e.g., 'gpt-image-1')
+ * @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* generateOpenAIImage(model, prompt, config) {
+  const apiKey = config.apiKeys?.openai;
+  if (!apiKey) {
+    throw new Error('OpenAI API key not configured. Run: otherwise config set openai <key>');
+  }
+
+  const client = new OpenAI({ apiKey });
+
+  try {
+    const response = await client.images.generate({
+      model,
+      prompt,
+      n: 1,
+      response_format: 'b64_json',
+      size: '1024x1024', // Default size
+    });
+
+    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 {
+      throw new Error('No image data returned from OpenAI');
+    }
+  } catch (error) {
+    console.error('[OpenAI Image] Generation error:', error);
+    throw error;
+  }
+}
+
+/**
+ * Stream chat completion from OpenAI GPT
+ * @param {string} model - Model identifier (e.g., 'gpt-4o')
+ * @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* streamOpenAI(model, messages, systemPrompt, config) {
+  const apiKey = config.apiKeys?.openai;
+  if (!apiKey) {
+    throw new Error('OpenAI API key not configured. Run: otherwise config set openai <key>');
+  }
+
+  // Route image models to the image generation function
+  if (isOpenAIImageModel(model)) {
+    const lastUserMessage = [...messages].reverse().find(m => m.role === 'user');
+    const prompt = lastUserMessage?.content || 'Generate an image';
+    yield* generateOpenAIImage(model, prompt, config);
+    return;
+  }
+
+  const client = new OpenAI({ apiKey });
+
+  // Convert messages to OpenAI format (vision: user messages can have images)
+  const openaiMessages = [
+    { role: 'system', content: systemPrompt },
+    ...messages.map(m => {
+      const role = m.role === 'user' ? 'user' : 'assistant';
+      // Vision: user message with images -> multimodal content array
+      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 };
+    }),
+  ];
+
+  // Some models (o-series, GPT-5) only support temperature=1
+  const isRestrictedTemp = /^o[0-9]|^gpt-5/.test(model);
+
+  const stream = await client.chat.completions.create({
+    model,
+    messages: openaiMessages,
+    max_completion_tokens: config.maxTokens || 8192,
+    stream: true,
+    stream_options: { include_usage: true }, // Get real token counts
+    ...(isRestrictedTemp ? {} : { temperature: config.temperature || 0.7 }),
+  });
+
+  let usage = null;
+
+  for await (const chunk of stream) {
+    const content = chunk.choices?.[0]?.delta?.content;
+    if (content) {
+      yield { type: 'text', content };
+    }
+    // Capture usage from final chunk (when stream_options.include_usage is true)
+    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 { streamOpenAI, generateOpenAIImage, isOpenAIImageModel };