markov-cli 1.0.10 → 1.0.12

package/src/ollama.js

@@ -1,12 +1,88 @@
-import { API_URL, getToken } from './auth.js';
+import { API_URL, getToken, getClaudeKey, getOpenAIKey } from './auth.js';
+import * as openai from './openai.js';
+import * as claude from './claude.js';
+
+function hasClaudeKey() {
+  const key = getClaudeKey();
+  return !!(key && key.trim());
+}
+
+function useClaude() {
+  return PROVIDER === 'claude' && hasClaudeKey();
+}
+
+function hasOpenAIKey() {
+  const key = getOpenAIKey();
+  return !!(key && key.trim());
+}
+
+function useOpenAI() {
+  return PROVIDER === 'openai' && hasOpenAIKey();
+}
+
+/**
+ * Strip <tool_call>...</tool_call> and similar pseudo-XML that sometimes appears in thinking/content
+ * when the model emits raw tool syntax instead of using the tool-calling API.
+ */
+function stripToolCallArtifacts(s) {
+  if (typeof s !== 'string' || !s) return s;
+  let out = s.replace(/<tool_call>[\s\S]*?<\/tool_call>/gi, '');
+  out = out.replace(/<tool_call>[\s\S]*$/i, ''); // incomplete block at end
+  return out;
+}
 
 const getHeaders = () => {
   const token = getToken();
   return { 'Content-Type': 'application/json', ...(token && { Authorization: `Bearer ${token}` }) };
 };
-export const MODELS = ['llama3:latest', 'gpt-oss:20b', 'qwen3:14b', 'qwen2.5:14b-instruct', 'qwen3.5:4b', 'qwen3.5:9b'];
-export let MODEL    = 'qwen3.5:9b';
-export function setModel(m) { MODEL = m; }
+
+/** Claude models: { label, model } */
+export const CLAUDE_MODELS = [
+  { label: 'Claude Haiku 4.5', model: 'claude-haiku-4-5-20251001' },
+  { label: 'Claude Sonnet 4', model: 'claude-sonnet-4-20250514' },
+  { label: 'Claude Opus 4', model: 'claude-opus-4-20250514' },
+];
+
+/** OpenAI models: { label, model } */
+export const OPENAI_MODELS = [
+  { label: 'GPT-4o mini', model: 'gpt-4o-mini' },
+  { label: 'GPT-4o', model: 'gpt-4o' },
+  { label: 'GPT-4o turbo', model: 'gpt-4-turbo' },
+];
+
+/** Ollama models (backend) */
+export const MODELS = ['qwen3.5:0.8b', 'qwen3.5:2b', 'qwen3.5:4b', 'qwen3.5:9b'];
+
+/** Combined options for /models picker: { label, provider, model } */
+export const MODEL_OPTIONS = [
+  ...CLAUDE_MODELS.map((o) => ({ label: o.label, provider: 'claude', model: o.model })),
+  ...OPENAI_MODELS.map((o) => ({ label: o.label, provider: 'openai', model: o.model })),
+  ...MODELS.map((m) => ({ label: `Ollama ${m}`, provider: 'ollama', model: m })),
+];
+
+export let PROVIDER = 'ollama';
+export let MODEL = 'qwen3.5:4b';
+
+export function setModel(m) {
+  MODEL = m;
+}
+
+export function setModelAndProvider(provider, model) {
+  PROVIDER = provider;
+  MODEL = model;
+}
+
+export function getModelDisplayName() {
+  if (PROVIDER === 'claude') {
+    const found = CLAUDE_MODELS.find((o) => o.model === MODEL);
+    return found ? found.label : `Claude ${MODEL}`;
+  }
+  if (PROVIDER === 'openai') {
+    const found = OPENAI_MODELS.find((o) => o.model === MODEL);
+    return found ? found.label : `OpenAI ${MODEL}`;
+  }
+  return `Ollama ${MODEL}`;
+}
 
 /**
  * Stream a chat response from Ollama.
@@ -16,13 +92,15 @@ export function setModel(m) { MODEL = m; }
  * @param {object} [opts] - Optional. { onThinkingToken?: (token: string) => void }
  */
 export async function streamChat(messages, onToken, _model = MODEL, signal = null, opts = {}) {
+  if (useClaude()) return claude.streamChat(messages, onToken, MODEL, signal, opts);
+  if (useOpenAI()) return openai.streamChat(messages, onToken, MODEL, signal, opts);
   const onThinkingToken = opts.onThinkingToken;
   let response;
   try {
     response = await fetch(`${API_URL}/ai/chat/stream`, {
       method: 'POST',
       headers: getHeaders(),
-      body: JSON.stringify({ messages, temperature: 0.2, think: true }),
+      body: JSON.stringify({ messages, temperature: 0.2 /* , think: true */ }),
       signal,
     });
   } catch (err) {
@@ -80,7 +158,10 @@ export async function streamChat(messages, onToken, _model = MODEL, signal = nul
  * Chat with tools (function calling). Non-streaming; returns full response with optional tool_calls.
  * Use for agent loop: if message.tool_calls present, run tools locally and call again with updated messages.
  */
-export async function chatWithTools(messages, tools, model = MODEL, signal = null) {
+export async function chatWithTools(messages, tools, model = MODEL, signal = null, providerOverride = null) {
+  const useBackend = providerOverride === 'ollama' || providerOverride === 'backend';
+  if (!useBackend && useClaude()) return claude.chatWithTools(messages, tools, MODEL, signal);
+  if (!useBackend && useOpenAI()) return openai.chatWithTools(messages, tools, MODEL, signal);
   const controller = signal ? { signal } : {};
   const res = await fetch(`${API_URL}/ai/chat/tools`, {
     method: 'POST',
@@ -95,3 +176,89 @@ export async function chatWithTools(messages, tools, model = MODEL, signal = nul
   const data = await res.json();
   return data;
 }
+
+/**
+ * Stream chat with tools: POST to ai/chat/stream with tools, consume SSE (content, thinking, tool_calls).
+ * Returns { content, toolCalls }. toolCalls is the last tool_calls array from the stream (if any).
+ * Use for agent loop: stream until done, then run tools and call again with updated messages.
+ * @param {Array} messages - Conversation messages
+ * @param {Array} tools - Ollama-format tool definitions
+ * @param {string} [model] - Model name
+ * @param {{ think?: boolean, onContent?: (chunk: string) => void, onThinking?: (chunk: string) => void }} callbacks - think: true only for plan mode (backend)
+ * @param {AbortSignal|null} signal
+ * @returns {Promise<{ content: string, toolCalls: Array|null }>}
+ */
+export async function streamChatWithTools(messages, tools, model = MODEL, callbacks = {}, signal = null, providerOverride = null) {
+  const useBackend = providerOverride === 'ollama' || providerOverride === 'backend';
+  if (!useBackend && useClaude()) return claude.streamChatWithTools(messages, tools, MODEL, callbacks, signal);
+  if (!useBackend && useOpenAI()) return openai.streamChatWithTools(messages, tools, MODEL, callbacks, signal);
+  const onContent = callbacks.onContent;
+  const onThinking = callbacks.onThinking;
+  const think = callbacks.think === true; // only plan mode passes think: true
+  const res = await fetch(`${API_URL}/ai/chat/stream`, {
+    method: 'POST',
+    headers: getHeaders(),
+    body: JSON.stringify({ messages, tools, model, temperature: 0.2, ...(think && { think: true }) }),
+    signal: signal || undefined,
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => '');
+    throw new Error(`API error ${res.status} ${res.statusText}${body ? ': ' + body : ''}`);
+  }
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  let fullContent = '';
+  let lastToolCalls = null;
+  let thinkingBuf = '';
+  let contentBuf = '';
+  let lastSentThinkingLen = 0;
+  let lastSentContentLen = 0;
+
+  try {
+    while (true) {
+      if (signal?.aborted) {
+        reader.cancel();
+        break;
+      }
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+
+      for (const line of lines) {
+        if (!line.startsWith('data: ')) continue;
+        const data = line.slice(6);
+        if (data === '[DONE]') return { content: fullContent, toolCalls: lastToolCalls, usage: null };
+
+        try {
+          const parsed = JSON.parse(data);
+          if (parsed.thinking != null && parsed.thinking !== '' && onThinking) {
+            thinkingBuf += parsed.thinking;
+            const cleaned = stripToolCallArtifacts(thinkingBuf);
+            const toSend = cleaned.slice(lastSentThinkingLen);
+            if (toSend) onThinking(toSend);
+            lastSentThinkingLen = cleaned.length;
+          }
+          if (parsed.content) {
+            contentBuf += parsed.content;
+            const cleaned = stripToolCallArtifacts(contentBuf);
+            const delta = cleaned.slice(lastSentContentLen);
+            fullContent += delta;
+            if (onContent && delta) onContent(delta);
+            lastSentContentLen = cleaned.length;
+          }
+          if (parsed.tool_calls && Array.isArray(parsed.tool_calls) && parsed.tool_calls.length > 0) {
+            lastToolCalls = parsed.tool_calls;
+          }
+        } catch (_) { /* skip malformed */ }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+
+  return { content: fullContent, toolCalls: lastToolCalls, usage: null };
+}

package/src/openai.js

@@ -0,0 +1,258 @@
+/**
+ * Temporary OpenAI (ChatGPT) client for the CLI.
+ * Used when OPENAI_API_KEY is set (env or ~/.markov); otherwise the CLI uses the backend (Ollama).
+ *
+ * Converts between CLI message format and OpenAI API format (tool_call_id, etc.).
+ */
+
+import { getOpenAIKey } from './auth.js';
+
+const OPENAI_API = 'https://api.openai.com/v1';
+const DEFAULT_MODEL = process.env.OPENAI_MODEL || 'gpt-4o-mini';
+
+function getHeaders() {
+  const key = getOpenAIKey();
+  if (!key || !key.trim()) throw new Error('OpenAI API key is not set');
+  return {
+    'Content-Type': 'application/json',
+    Authorization: `Bearer ${key.trim()}`,
+  };
+}
+
+/**
+ * Convert CLI messages to OpenAI format.
+ * - Assistant tool_calls must have id for OpenAI.
+ * - Tool messages: CLI uses tool_name; OpenAI uses tool_call_id. We assign ids by order from the previous assistant's tool_calls.
+ */
+function toOpenAIMessages(messages) {
+  const out = [];
+  let lastToolCallIds = [];
+
+  for (const m of messages) {
+    if (m.role === 'system') {
+      out.push({ role: 'system', content: typeof m.content === 'string' ? m.content : '' });
+      continue;
+    }
+    if (m.role === 'user') {
+      out.push({ role: 'user', content: typeof m.content === 'string' ? m.content : '' });
+      lastToolCallIds = [];
+      continue;
+    }
+    if (m.role === 'assistant') {
+      const msg = { role: 'assistant', content: typeof m.content === 'string' ? m.content : '' };
+      if (m.tool_calls && Array.isArray(m.tool_calls) && m.tool_calls.length > 0) {
+        msg.tool_calls = m.tool_calls.map((tc) => ({
+          id: tc.id || `call_${Math.random().toString(36).slice(2)}`,
+          type: 'function',
+          function: {
+            name: tc.function?.name ?? 'unknown',
+            arguments: typeof tc.function?.arguments === 'string' ? tc.function.arguments : JSON.stringify(tc.function?.arguments ?? {}),
+          },
+        }));
+        lastToolCallIds = msg.tool_calls.map((tc) => tc.id);
+      }
+      out.push(msg);
+      continue;
+    }
+    if (m.role === 'tool') {
+      const id = lastToolCallIds[out.filter((x) => x.role === 'tool').length] ?? lastToolCallIds[0];
+      if (id) out.push({ role: 'tool', tool_call_id: id, content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content ?? '') });
+    }
+  }
+  return out;
+}
+
+/**
+ * Convert Ollama-format tools to OpenAI format. Already compatible: { type: 'function', function: { name, description, parameters } }.
+ */
+function toOpenAITools(tools) {
+  if (!tools || tools.length === 0) return undefined;
+  return tools.map((t) => {
+    const f = t.function ?? t;
+    return {
+      type: 'function',
+      function: {
+        name: f.name,
+        description: f.description ?? '',
+        parameters: f.parameters ?? { type: 'object', properties: {} },
+      },
+    };
+  });
+}
+
+/**
+ * Stream chat (no tools). Same signature as ollama.js streamChat.
+ */
+export async function streamChat(messages, onToken, _model = DEFAULT_MODEL, signal = null, opts = {}) {
+  const openaiMessages = toOpenAIMessages(messages);
+  const res = await fetch(`${OPENAI_API}/chat/completions`, {
+    method: 'POST',
+    headers: getHeaders(),
+    body: JSON.stringify({
+      model: _model,
+      messages: openaiMessages,
+      stream: true,
+      temperature: 0.2,
+    }),
+    signal: signal || undefined,
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => '');
+    throw new Error(`OpenAI API error ${res.status} ${res.statusText}${body ? ': ' + body : ''}`);
+  }
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  let fullText = '';
+
+  try {
+    while (true) {
+      if (signal?.aborted) {
+        reader.cancel();
+        break;
+      }
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+      for (const line of lines) {
+        if (!line.startsWith('data: ')) continue;
+        const data = line.slice(6).trim();
+        if (data === '[DONE]') return fullText;
+        try {
+          const parsed = JSON.parse(data);
+          const delta = parsed.choices?.[0]?.delta;
+          if (delta?.content) {
+            fullText += delta.content;
+            onToken(delta.content);
+          }
+        } catch (_) { /* skip */ }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return fullText;
+}
+
+/**
+ * Chat with tools (non-streaming). Returns { message } with message.content and optional message.tool_calls.
+ * Tool calls use OpenAI format (id, type, function); we return as-is so the CLI can pass them back and we map via toOpenAIMessages.
+ */
+export async function chatWithTools(messages, tools, model = DEFAULT_MODEL, signal = null) {
+  const openaiMessages = toOpenAIMessages(messages);
+  const openaiTools = toOpenAITools(tools);
+  const res = await fetch(`${OPENAI_API}/chat/completions`, {
+    method: 'POST',
+    headers: getHeaders(),
+    body: JSON.stringify({
+      model,
+      messages: openaiMessages,
+      stream: false,
+      temperature: 0.2,
+      tools: openaiTools ? openaiTools : undefined,
+    }),
+    signal: signal || undefined,
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => '');
+    throw new Error(`OpenAI API error ${res.status} ${res.statusText}${body ? ': ' + body : ''}`);
+  }
+  const data = await res.json();
+  const choice = data.choices?.[0];
+  if (!choice) throw new Error('OpenAI API returned no choices');
+  const msg = choice.message ?? {};
+  return {
+    message: {
+      role: 'assistant',
+      content: msg.content ?? '',
+      tool_calls: msg.tool_calls ?? undefined,
+    },
+    usage: data.usage ?? null,
+  };
+}
+
+/**
+ * Stream chat with tools. Accumulates content and tool_calls from delta; tool_calls are sent incrementally so we merge by index.
+ * Returns { content, toolCalls } where toolCalls are in OpenAI format (id, type, function) for the next request.
+ */
+export async function streamChatWithTools(messages, tools, model = DEFAULT_MODEL, callbacks = {}, signal = null) {
+  const onContent = callbacks.onContent;
+  const onThinking = callbacks.onThinking; // OpenAI doesn't send "thinking"; no-op or skip
+  const openaiMessages = toOpenAIMessages(messages);
+  const openaiTools = toOpenAITools(tools);
+  const res = await fetch(`${OPENAI_API}/chat/completions`, {
+    method: 'POST',
+    headers: getHeaders(),
+    body: JSON.stringify({
+      model,
+      messages: openaiMessages,
+      stream: true,
+      temperature: 0.2,
+      tools: openaiTools ? openaiTools : undefined,
+    }),
+    signal: signal || undefined,
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => '');
+    throw new Error(`OpenAI API error ${res.status} ${res.statusText}${body ? ': ' + body : ''}`);
+  }
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  let fullContent = '';
+  const toolCallsAccum = {}; // index -> { id, type, function: { name, arguments } }
+  let usage = null;
+
+  try {
+    while (true) {
+      if (signal?.aborted) {
+        reader.cancel();
+        break;
+      }
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+      for (const line of lines) {
+        if (!line.startsWith('data: ')) continue;
+        const data = line.slice(6).trim();
+        if (data === '[DONE]') break;
+        try {
+          const parsed = JSON.parse(data);
+          if (parsed.usage) usage = parsed.usage;
+          const delta = parsed.choices?.[0]?.delta;
+          if (!delta) continue;
+          if (delta.content) {
+            fullContent += delta.content;
+            if (onContent) onContent(delta.content);
+          }
+          if (delta.tool_calls && Array.isArray(delta.tool_calls)) {
+            for (const tc of delta.tool_calls) {
+              const i = tc.index;
+              if (toolCallsAccum[i] == null) {
+                toolCallsAccum[i] = { id: tc.id ?? '', type: 'function', function: { name: '', arguments: '' } };
+              }
+              if (tc.id) toolCallsAccum[i].id = tc.id;
+              if (tc.function?.name) toolCallsAccum[i].function.name += tc.function.name || '';
+              if (tc.function?.arguments) toolCallsAccum[i].function.arguments += tc.function.arguments || '';
+            }
+          }
+        } catch (_) { /* skip */ }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+
+  const toolCallsArray = Object.keys(toolCallsAccum)
+    .sort((a, b) => Number(a) - Number(b))
+    .map((k) => toolCallsAccum[k])
+    .filter((tc) => tc.id || tc.function?.name);
+
+  return { content: fullContent, toolCalls: toolCallsArray.length > 0 ? toolCallsArray : null, usage };
+}
+
+export const OPENAI_MODEL = DEFAULT_MODEL;