codeply-cli 0.5.1 → 0.5.2

package/lib/ai.js

@@ -133,6 +133,26 @@ async function withRetries(send, signal) {
 // native-shaped history can never reach an endpoint that would reject it.
 
 /** Native history -> plain text turns (tool calls described, results as user text). */
+// reasoning_content rides along on assistant turns (agent.mjs). DeepSeek's
+// thinking mode requires it back on every step of a tool run; everyone else
+// gets it stripped, since some providers reject unknown message fields.
+function wantsReasoningBack(url, model) {
+  return /deepseek/i.test(String(url || '')) || /deepseek/i.test(String(model || ''));
+}
+function wireMessages(messages, url, model) {
+  if (wantsReasoningBack(url, model)) {
+    // A step with no reasoning still needs the field (an empty one is accepted).
+    if (!messages.some((m) => m && m.role === 'assistant' && m.tool_calls && m.reasoning_content === undefined)) return messages;
+    return messages.map((m) => (m && m.role === 'assistant' && m.tool_calls && m.reasoning_content === undefined ? { ...m, reasoning_content: '' } : m));
+  }
+  if (!messages.some((m) => m && m.reasoning_content !== undefined)) return messages;
+  return messages.map((m) => {
+    if (!m || m.reasoning_content === undefined) return m;
+    const { reasoning_content, ...rest } = m;
+    return rest;
+  });
+}
+
 function textOnlyMessages(messages) {
   if (!messages.some((m) => m.role === 'tool' || m.tool_calls)) return messages;
   const out = [];
@@ -141,7 +161,7 @@ function textOnlyMessages(messages) {
       out.push({ role: 'user', content: `[tool result: ${m.name || 'tool'}]\n${typeof m.content === 'string' ? m.content : JSON.stringify(m.content)}` });
     } else if (m.tool_calls) {
       const calls = m.tool_calls.map((c) => `[called ${c.function?.name}(${String(c.function?.arguments || '').slice(0, 400)})]`).join('\n');
-      out.push({ role: 'assistant', content: [m.content || '', calls].filter(Boolean).join('\n') });
+      out.push({ role: 'assistant', content: [m.content || '', calls].filter(Boolean).join('\n'), ...(m.reasoning_content !== undefined ? { reasoning_content: m.reasoning_content } : {}) });
     } else {
       out.push(m);
     }
@@ -274,7 +294,7 @@ async function chatViaProxy(messages, opts) {
         // the proxy logs it to usage_history so CLI activity shows up in the
         // admin dashboard next to the desktop app, same as this app's own calls.
         // The proxy declares no tools, so it only ever gets text history.
-        body: JSON.stringify({ messages: textOnlyMessages(messages), opts: { ...opts, tools: undefined }, meta: opts.meta }),
+        body: JSON.stringify({ messages: wireMessages(textOnlyMessages(messages)), opts: { ...opts, tools: undefined }, meta: opts.meta }),
         signal,
       });
       body = await res.json().catch(() => ({}));
@@ -376,6 +396,22 @@ async function chatViaOllama(messages, opts, cfg) {
   return last;
 }
 
+// Newer models refuse a temperature setting ("temperature is deprecated for
+// this model": Claude 4.5 and later, OpenAI's o-series and GPT-5). Those never
+// get one; any other model that refuses it once is remembered and retried
+// straight away without it.
+const NO_TEMPERATURE = /^(claude-(opus|sonnet|haiku)-(4-[5-9]|[5-9])|claude-fable|o\d|gpt-5)/i;
+const temperatureRefused = new Set();
+const sendsTemperature = (model) => !NO_TEMPERATURE.test(String(model || '').replace(/^[\w.-]+\//, '')) && !temperatureRefused.has(model);
+const temperatureParam = (model, opts) => (sendsTemperature(model) ? { temperature: opts.temperature ?? 0 } : {});
+/** The provider refused the temperature: remember it for this model, and say whether to retry. */
+function refusedTemperature(model, msg) {
+  if (!/temperature/i.test(msg) || !/deprecat|not supported|unsupported|does not support|only the default|not allowed|invalid/i.test(msg)) return false;
+  if (temperatureRefused.has(model)) return false;
+  temperatureRefused.add(model);
+  return true;
+}
+
 function ollamaRequest(host, model, apiKey, isLocal, messages, opts, numCtx, hasSpare) {
   return streamingChatRequest({
     url: `${host}/v1/chat/completions`, label: 'Ollama', model, apiKey, isLocal, messages, opts, hasSpare,
@@ -410,8 +446,8 @@ async function streamingChatRequest({ url, label, model, apiKey, isLocal, messag
         headers,
         body: JSON.stringify({
           model,
-          messages: opts.tools ? messages : textOnlyMessages(messages),
-          temperature: opts.temperature ?? 0,
+          messages: wireMessages(opts.tools ? messages : textOnlyMessages(messages), url, model),
+          ...temperatureParam(model, opts),
           ...(opts.maxTokens ? { max_tokens: opts.maxTokens } : {}),
           ...(opts.json ? { response_format: { type: 'json_object' } } : {}),
           ...(opts.tools ? { tools: opts.tools, tool_choice: 'auto' } : {}),
@@ -449,6 +485,7 @@ async function streamingChatRequest({ url, label, model, apiKey, isLocal, messag
       const apiError = body?.error?.message || body?.error;
       if (apiError) {
         const msg = typeof apiError === 'string' ? apiError : JSON.stringify(apiError);
+        if (refusedTemperature(model, msg)) return { retryable: true, retryAfterMs: 0, error: `${label}: ${msg}` };
         const fatal = /not found|does not exist|unknown model|unauthor|invalid.*key|forbidden/i.test(msg);
         if (fatal) return { done: true, value: { success: false, error: `${label}: ${msg}` } };
         // Another account is standing by, and this failure is this account's
@@ -616,8 +653,8 @@ async function chatViaOpenAICompatible(messages, opts, providerName, cfg) {
         },
         body: JSON.stringify({
           model,
-          messages: opts.tools ? messages : textOnlyMessages(messages),
-          temperature: opts.temperature ?? 0,
+          messages: wireMessages(opts.tools ? messages : textOnlyMessages(messages), url, model),
+          ...temperatureParam(model, opts),
           ...(opts.maxTokens ? { max_tokens: opts.maxTokens } : {}),
           ...(opts.json ? { response_format: { type: 'json_object' } } : {}),
           ...(opts.tools ? { tools: opts.tools, tool_choice: 'auto' } : {}),
@@ -645,6 +682,7 @@ async function chatViaOpenAICompatible(messages, opts, providerName, cfg) {
     const apiError = body?.error?.message || body?.error;
     if (apiError) {
       const msg = typeof apiError === 'string' ? apiError : JSON.stringify(apiError);
+      if (refusedTemperature(model, msg)) return { retryable: true, retryAfterMs: 0, error: `${label}: ${msg}` };
       const fatal = /not found|does not exist|unknown model|unauthor|invalid.*key|forbidden/i.test(msg);
       if (fatal) return { done: true, value: { success: false, error: `${label}: ${msg}` } };
       return { retryable: isTransientStatus(res.status), retryAfterMs: retryAfterMs(res), error: `${label}: ${msg}` };
@@ -768,7 +806,7 @@ async function chatViaAnthropic(messages, opts, cfg) {
           system,
           messages: turns,
           max_tokens: opts.maxTokens || 8192,
-          temperature: opts.temperature ?? 0,
+          ...temperatureParam(model, opts),
           ...(opts.tools ? { tools: toAnthropicTools(opts.tools) } : {}),
         }),
         signal: opts.signal,
@@ -916,11 +954,13 @@ async function chatViaOllamaNative(messages, opts, m) {
       cleanup();
       if (isTimeout()) return { retryable: true, error: `Ollama at ${host} didn't respond in time. Large models can take a while to load - try again, or pick a smaller model.` };
       if (isAbortError(e)) return { aborted: true };
+      if (m.research === 'local') return { done: true, value: { success: false, error: researchMode().ERR_LOCAL_DOWN } };
       return { retryable: false, error: local ? `Can't reach Ollama at ${host}. Is Ollama running? (Start it with \`ollama serve\` or open the Ollama app.)` : `Can't reach ${host}: ${e.message}` };
     }
 
     if (!res.ok) {
       cleanup();
+      if (m.research === 'cloud' && (res.status === 401 || res.status === 403)) return { done: true, value: { success: false, error: researchMode().ERR_CLOUD_KEY } };
       const body = await res.json().catch(() => ({}));
       const msg = body.error || describeStatus(res.status);
       const fatal = res.status === 404 || /not found|pull/i.test(String(msg));
@@ -945,7 +985,10 @@ async function chatViaOllamaNative(messages, opts, m) {
           let evt;
           try { evt = JSON.parse(line); } catch { continue; }
           if (evt.error) streamError = evt.error;
-          if (evt.message?.content) content += evt.message.content;
+          if (evt.message?.content) {
+            content += evt.message.content;
+            if (opts.onToken) { try { opts.onToken(evt.message.content); } catch {} }
+          }
           if (evt.message?.thinking) reasoning += evt.message.thinking;
           // Ollama sends each tool call whole (arguments as an object).
           for (const tc of evt.message?.tool_calls || []) {
@@ -974,7 +1017,176 @@ async function chatViaOllamaNative(messages, opts, m) {
   }, opts.signal);
 }
 
+// ─── ChatGPT plan (Sign in with ChatGPT) ────────────────────────────────────
+// The token from chatgpt.js only works against the Responses API, and only
+// with store:false + stream:true. Craft's history is chat-completions shaped,
+// so it's converted on the way in and the stream reassembled into the same
+// {choices:[{message}]} shape every other path returns.
+
+function toResponsesContent(content, role) {
+  if (typeof content === 'string' || !Array.isArray(content)) {
+    return [{ type: role === 'assistant' ? 'output_text' : 'input_text', text: String(content || '') }];
+  }
+  return content.map((p) => {
+    if (p.type === 'image_url') return { type: 'input_image', image_url: p.image_url?.url || p.image_url };
+    return { type: role === 'assistant' ? 'output_text' : 'input_text', text: p.text || '' };
+  });
+}
+
+function toResponsesRequest(messages, opts) {
+  const instructions = [];
+  const input = [];
+  for (const m of opts.tools ? messages : textOnlyMessages(messages)) {
+    if (m.role === 'system') {
+      instructions.push(typeof m.content === 'string' ? m.content : toResponsesContent(m.content).map((p) => p.text).join('\n'));
+    } else if (m.role === 'tool') {
+      input.push({ type: 'function_call_output', call_id: m.tool_call_id, output: typeof m.content === 'string' ? m.content : JSON.stringify(m.content) });
+    } else {
+      const hasText = Array.isArray(m.content) ? m.content.length > 0 : !!m.content;
+      if (hasText) input.push({ role: m.role, content: toResponsesContent(m.content, m.role) });
+      for (const c of m.tool_calls || []) {
+        input.push({ type: 'function_call', call_id: c.id, name: c.function?.name, arguments: c.function?.arguments || '{}' });
+      }
+    }
+  }
+  const body = { model: opts.model, input, store: false, stream: true };
+  if (instructions.length) body.instructions = instructions.join('\n\n');
+  if (opts.maxTokens) body.max_output_tokens = Math.max(16, opts.maxTokens);
+  if (opts.tools) {
+    body.tools = opts.tools.map((t) => ({ type: 'function', name: t.function.name, description: t.function.description, parameters: t.function.parameters }));
+    body.tool_choice = 'auto';
+  }
+  return body;
+}
+
+// Plan-usage errors come back as structured codes; these are the ones a
+// person can act on (developers.openai.com/siwc/token-sharing-open-source/errors-and-recovery).
+function chatgptErrorMessage(code, fallback) {
+  switch (code) {
+    case 'subscription_sharing_usage_limit_exceeded':
+      return 'You reached the ChatGPT plan usage allowed for Craft. Manage usage at chatgpt.com/settings/usage, or pick another model.';
+    case 'subscription_sharing_user_not_eligible':
+      return 'Your ChatGPT plan or workspace can’t be used in other apps. Pick another model, or check your plan at chatgpt.com.';
+    case 'subscription_sharing_invalid_user':
+      return 'Your ChatGPT sign-in is no longer valid. Sign in again from the model menu.';
+    case 'subscription_sharing_unsupported_capability':
+      return `ChatGPT plan models don’t support part of this request (${fallback}).`;
+    default:
+      return fallback;
+  }
+}
+const CHATGPT_RETRYABLE = new Set(['subscription_sharing_usage_unavailable', 'subscription_sharing_user_unavailable']);
+
+async function chatViaChatGPT(messages, opts, m) {
+  const chatgpt = require('./chatgpt.js');
+  const label = m.name || m.model;
+  let refreshed = false;
+  return withRetries(async () => {
+    let token;
+    try { token = await chatgpt.accessToken({ force: refreshed }); } catch (e) {
+      return { done: true, value: { success: false, error: e.message } };
+    }
+    let res;
+    const { signal, poke, isTimeout, cleanup } = withIdleTimeout(opts.signal, REQUEST_TIMEOUT_MS);
+    try {
+      res = await fetch(`${chatgpt.RESOURCE}/responses`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${token}` },
+        body: JSON.stringify(toResponsesRequest(messages, { ...opts, model: m.model })),
+        signal,
+      });
+    } catch (e) {
+      cleanup();
+      if (isTimeout()) return { retryable: true, error: `${label} timed out with no response - retrying.` };
+      if (isAbortError(e)) return { aborted: true };
+      return { retryable: true, error: `Couldn't reach ChatGPT: ${e.message}` };
+    }
+
+    if (!res.ok) {
+      cleanup();
+      const body = await res.json().catch(() => ({}));
+      const code = body?.error?.code || body?.code;
+      const msg = body?.error?.message || describeStatus(res.status);
+      // An expired access token: refresh once and go again.
+      if (res.status === 401 && !refreshed && code !== 'subscription_sharing_invalid_user') {
+        refreshed = true;
+        return { retryable: true, retryAfterMs: 0, error: msg };
+      }
+      const text = `${label}: ${chatgptErrorMessage(code, msg)}`;
+      if (CHATGPT_RETRYABLE.has(code) || res.status === 503) return { retryable: true, retryAfterMs: retryAfterMs(res), error: text };
+      return { done: true, value: { success: false, error: text } };
+    }
+
+    let content = '';
+    let reasoning = '';
+    let modelUsed = m.model;
+    let failure = null;
+    let completed = false;
+    const toolCalls = [];
+    let buffer = '';
+    try {
+      for await (const chunk of res.body) {
+        poke();
+        buffer += Buffer.isBuffer(chunk) ? chunk.toString('utf8') : Buffer.from(chunk).toString('utf8');
+        let nl;
+        while ((nl = buffer.indexOf('\n')) !== -1) {
+          const line = buffer.slice(0, nl).trim();
+          buffer = buffer.slice(nl + 1);
+          if (!line.startsWith('data:')) continue;
+          const payload = line.slice(5).trim();
+          if (!payload || payload === '[DONE]') continue;
+          let evt;
+          try { evt = JSON.parse(payload); } catch { continue; }
+          switch (evt.type) {
+            case 'response.output_text.delta': content += evt.delta || ''; break;
+            case 'response.reasoning_summary_text.delta':
+            case 'response.reasoning_text.delta': reasoning += evt.delta || ''; break;
+            case 'response.output_item.done':
+              if (evt.item?.type === 'function_call') {
+                toolCalls.push({
+                  id: evt.item.call_id || evt.item.id || `call_${Date.now().toString(36)}_${toolCalls.length}`,
+                  type: 'function',
+                  function: { name: evt.item.name, arguments: evt.item.arguments || '{}' },
+                });
+              }
+              break;
+            case 'response.completed':
+              completed = true;
+              modelUsed = evt.response?.model || modelUsed;
+              break;
+            case 'response.failed':
+            case 'response.incomplete':
+            case 'error': {
+              const err = evt.response?.error || evt.error || evt;
+              failure = { code: err.code, message: err.message || evt.response?.incomplete_details?.reason || 'the response did not finish' };
+              break;
+            }
+          }
+        }
+      }
+    } catch (e) {
+      if (isTimeout()) return { retryable: true, error: `${label} stopped sending data mid-response (stalled stream) - retrying.` };
+      if (isAbortError(e)) return { aborted: true };
+      return { retryable: true, error: `${label} stream interrupted: ${e.message}` };
+    } finally {
+      cleanup();
+    }
+
+    if (failure && !content && !toolCalls.length) {
+      const text = `${label}: ${chatgptErrorMessage(failure.code, failure.message)}`;
+      return CHATGPT_RETRYABLE.has(failure.code) ? { retryable: true, error: text } : { done: true, value: { success: false, error: text } };
+    }
+    if (!completed && !content && !toolCalls.length) return { retryable: true, error: `${label} ended the stream without an answer - retrying.` };
+
+    const message = { role: 'assistant', content };
+    if (reasoning) message.reasoning = reasoning;
+    if (toolCalls.length) message.tool_calls = toolCalls;
+    return { done: true, value: { success: true, data: { choices: [{ message, finish_reason: toolCalls.length ? 'tool_calls' : 'stop' }], model: modelUsed }, modelUsed } };
+  }, opts.signal);
+}
+
 function chatViaCustom(messages, opts, m) {
+  if (m.kind === 'chatgpt') return chatViaChatGPT(messages, opts, m);
   if (m.kind === 'ollama') return chatViaOllamaNative(messages, opts, m);
   const url = chatCompletionsUrl(m.baseUrl);
   const local = isLocalUrl(url);
@@ -1033,7 +1245,54 @@ async function chatViaAuto(messages, opts) {
   return r;
 }
 
+/**
+ * Research Mode: all inference goes to local Ollama (/api/chat) or Ollama
+ * Cloud (bearer key), streaming through chatViaOllamaNative. opts.onToken
+ * receives each token as it arrives.
+ */
+function researchMode() {
+  const ollama = require('../research-mode/ollama.js');
+  const pre = require('../research-mode/preprocessor.js');
+  return { ...ollama, ...pre };
+}
+
+async function chatResearch(messages, opts, rm) {
+  const rmod = researchMode();
+  const target = rmod.resolveTarget(rm);
+  if (target.error) return { success: false, error: target.error };
+  if (!rm.model) return { success: false, error: 'Pick a model in Research Mode settings.' };
+  const pre = rmod.preprocess({ messages, mode: rm.mode, model: rm.model, researchContext: rm.context });
+  return chatViaOllamaNative(rmod.withSystem(pre), opts, { baseUrl: target.host, model: rm.model, apiKey: target.apiKey, research: rm.mode === 'cloud' ? 'cloud' : 'local' });
+}
+
+/** Which route a request takes, for the usage counts (telemetry.js). */
+function providerOf(opts) {
+  const rm = getConfig().research;
+  if (rm && rm.enabled) return 'research';
+  if (opts.route && opts.route.custom) return opts.route.custom.kind === 'chatgpt' ? 'chatgpt' : opts.route.custom.kind === 'ollama' ? 'ollama' : 'byok';
+  if (opts.route && opts.route.auto) return 'auto';
+  const p = applyRoute(getConfig(), opts.route).provider;
+  return p === 'ollama' ? 'ollama' : ['anthropic', 'openrouter', 'groq', 'openai', 'google', 'qwen', 'deepseek'].includes(p) ? 'byok' : 'proxy';
+}
+
+/** Every model call, counted (which app, which model, tokens; never content). */
 async function chat(messages, opts = {}) {
+  const started = Date.now();
+  const r = await chatRouted(messages, opts);
+  if (r && r.success) {
+    try {
+      const telemetry = require('./telemetry.js');
+      const model = r.modelUsed || (r.data && r.data.model) || (opts.route && opts.route.custom && opts.route.custom.model) || '';
+      telemetry.recordAi({ model: String(model).slice(0, 120), provider: providerOf(opts), ms: Date.now() - started, ...telemetry.tokensOf(r.data, messages) });
+    } catch {}
+  }
+  return r;
+}
+
+async function chatRouted(messages, opts = {}) {
+  // Research Mode, when switched on in settings, takes every request.
+  const rm = getConfig().research;
+  if (rm && rm.enabled) return chatResearch(messages, opts, rm);
   // A user-added model (desktop model picker) always wins when routed.
   if (opts.route && opts.route.custom) return chatViaCustom(messages, opts, opts.route.custom);
   // Auto in the desktop app = the hosted Codeply model, regardless of what
@@ -1104,4 +1363,4 @@ async function chatJson(messages, opts = {}) {
   return { success: true, json: parsed, usage: r.data.usage || {}, modelUsed: r.modelUsed };
 }
 
-module.exports = { chat, chatJson, isRateLimitError, listOllamaModels, testModel, chatCompletionsUrl };
+module.exports = { chatResearch, chat, chatJson, isRateLimitError, listOllamaModels, testModel, chatCompletionsUrl };

package/lib/ai.mjs

@@ -1,6 +1,6 @@
-import { createRequire } from 'module';
-const require = createRequire(import.meta.url);
-
-const ai = require('../lib/ai.js');
-export default ai;
-export const { chat, chatJson, isRateLimitError } = ai;
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+
+const ai = require('../lib/ai.js');
+export default ai;
+export const { chat, chatJson, isRateLimitError } = ai;