codemini-cli 0.3.3 → 0.3.5

package/src/core/provider/openai-compatible.js

@@ -1,5 +1,3 @@
-import OpenAI from 'openai';
-
 function extractTextContent(content) {
   if (typeof content === 'string') return content;
   if (Array.isArray(content)) {
@@ -14,6 +12,20 @@ function extractTextContent(content) {
   return '';
 }
 
+function extractReasoningContent(payload) {
+  if (typeof payload === 'string') return payload;
+  if (Array.isArray(payload)) {
+    return payload
+      .map((part) => {
+        if (part?.type === 'reasoning') return part.text || '';
+        if (part?.type === 'reasoning_content') return part.text || part.reasoning_content || '';
+        return '';
+      })
+      .join('');
+  }
+  return '';
+}
+
 function emptyToolCall(index) {
   return {
     index,
@@ -23,13 +35,59 @@ function emptyToolCall(index) {
   };
 }
 
-function createClient({ baseUrl, apiKey, timeoutMs, maxRetries }) {
-  return new OpenAI({
-    apiKey,
-    baseURL: baseUrl,
-    timeout: timeoutMs,
-    maxRetries
-  });
+function createHeaders(apiKey) {
+  return {
+    'content-type': 'application/json',
+    authorization: `Bearer ${apiKey}`
+  };
+}
+
+function buildChatCompletionsUrl(baseUrl) {
+  return `${String(baseUrl || '').replace(/\/$/, '')}/chat/completions`;
+}
+
+async function parseJsonResponse(response) {
+  if (!response.ok) {
+    const text = await response.text().catch(() => '');
+    throw new Error(`Gateway error ${response.status}: ${text || response.statusText}`);
+  }
+  return response.json();
+}
+
+async function* iterateSseEvents(stream) {
+  const decoder = new TextDecoder();
+  let buffer = '';
+  const flushEvent = (rawEvent) => {
+    const dataLines = String(rawEvent || '')
+      .split(/\r?\n/)
+      .filter((line) => line.startsWith('data:'))
+      .map((line) => line.slice(5).trimStart());
+    const dataText = dataLines.join('\n');
+    if (!dataText || dataText === '[DONE]') return null;
+    return JSON.parse(dataText);
+  };
+
+  for await (const chunk of stream) {
+    buffer += decoder.decode(chunk, { stream: true });
+    while (true) {
+      const lfBoundary = buffer.indexOf('\n\n');
+      const crlfBoundary = buffer.indexOf('\r\n\r\n');
+      if (lfBoundary === -1 && crlfBoundary === -1) break;
+      const useCrlf = crlfBoundary !== -1 && (lfBoundary === -1 || crlfBoundary < lfBoundary);
+      const boundary = useCrlf ? crlfBoundary : lfBoundary;
+      const separatorLength = useCrlf ? 4 : 2;
+      const rawEvent = buffer.slice(0, boundary);
+      buffer = buffer.slice(boundary + separatorLength);
+      const parsed = flushEvent(rawEvent);
+      if (parsed) yield parsed;
+    }
+  }
+
+  buffer += decoder.decode();
+  const trailingEvent = flushEvent(buffer.trim());
+  if (trailingEvent) {
+    yield trailingEvent;
+  }
 }
 
 function isMiniMaxModel(model) {
@@ -78,6 +136,27 @@ function sanitizeGatewayMessages(messages) {
     });
 }
 
+function buildAssistantMessage({ text = '', toolCalls = [], content, reasoningContent = '' }) {
+  const assistantMessage = {
+    role: 'assistant',
+    content: content ?? text
+  };
+  if (reasoningContent) {
+    assistantMessage.reasoning_content = reasoningContent;
+  }
+  if (Array.isArray(toolCalls) && toolCalls.length > 0) {
+    assistantMessage.tool_calls = toolCalls.map((tc) => ({
+      id: tc.id,
+      type: 'function',
+      function: {
+        name: tc.name,
+        arguments: tc.arguments || '{}'
+      }
+    }));
+  }
+  return assistantMessage;
+}
+
 function sanitizeMiniMaxMessages(messages) {
   const source = Array.isArray(messages) ? messages : [];
   const out = [];
@@ -238,12 +317,17 @@ export async function createChatCompletion({
   timeoutMs = 90000,
   maxRetries = 2
 }) {
-  const client = createClient({ baseUrl, apiKey, timeoutMs, maxRetries });
   const payload = buildPayload({ model, temperature, messages, tools });
-
-  const data = await client.chat.completions.create(payload);
+  const response = await fetch(buildChatCompletionsUrl(baseUrl), {
+    method: 'POST',
+    headers: createHeaders(apiKey),
+    body: JSON.stringify(payload),
+    signal: AbortSignal.timeout(timeoutMs)
+  });
+  const data = await parseJsonResponse(response);
   const message = data?.choices?.[0]?.message || {};
   const text = sanitizeMiniMaxText(model, extractTextContent(message.content));
+  const reasoningContent = extractReasoningContent(message.reasoning_content);
   const toolCalls = (message.tool_calls || []).map((tc) => ({
     id: tc.id,
     name: tc.function?.name,
@@ -266,7 +350,13 @@ export async function createChatCompletion({
   return {
     text,
     toolCalls,
-    usage: data?.usage || null
+    usage: data?.usage || null,
+    assistantMessage: buildAssistantMessage({
+      text,
+      toolCalls,
+      content: message.content ?? text,
+      reasoningContent
+    })
   };
 }
 
@@ -282,20 +372,32 @@ export async function createChatCompletionStream({
   timeoutMs = 90000,
   maxRetries = 2
 }) {
-  const client = createClient({ baseUrl, apiKey, timeoutMs, maxRetries });
   const payload = buildPayload({ model, temperature, messages, tools, stream: true });
-
-  const stream = await client.chat.completions.create(payload);
+  const response = await fetch(buildChatCompletionsUrl(baseUrl), {
+    method: 'POST',
+    headers: createHeaders(apiKey),
+    body: JSON.stringify(payload),
+    signal: AbortSignal.timeout(timeoutMs)
+  });
+  if (!response.ok || !response.body) {
+    const text = await response.text().catch(() => '');
+    throw new Error(`Gateway error ${response.status}: ${text || response.statusText}`);
+  }
   let text = '';
+  let reasoningContent = '';
   const toolCallsByIndex = new Map();
   let usage = null;
   let miniMaxStreamState = { rawContent: '', visibleText: '' };
 
-  for await (const chunk of stream) {
+  for await (const chunk of iterateSseEvents(response.body)) {
     usage = chunk?.usage || usage;
     const choice0 = chunk?.choices?.[0] || {};
     const delta = choice0?.delta || {};
     const content = delta.content;
+    const reasoningDelta = extractReasoningContent(delta.reasoning_content);
+    if (reasoningDelta) {
+      reasoningContent += reasoningDelta;
+    }
     if (isMiniMaxModel(model)) {
       const next = nextMiniMaxVisibleChunk(miniMaxStreamState, content);
       miniMaxStreamState = next.nextState;
@@ -333,7 +435,19 @@ export async function createChatCompletionStream({
         });
       }
     }
+
+    if (choice0?.finish_reason) {
+      break;
+    }
   }
 
-  return buildFinalStreamResult(text, toolCallsByIndex, usage, messages);
+  const result = buildFinalStreamResult(text, toolCallsByIndex, usage, messages);
+  return {
+    ...result,
+    assistantMessage: buildAssistantMessage({
+      text: result.text,
+      toolCalls: result.toolCalls,
+      reasoningContent
+    })
+  };
 }

package/src/core/provider/openai-compatible.sdk-backup.js

@@ -0,0 +1,412 @@
+import OpenAI from 'openai';
+
+function extractTextContent(content) {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((part) => {
+        if (typeof part === 'string') return part;
+        if (part?.type === 'text') return part.text || '';
+        return '';
+      })
+      .join('');
+  }
+  return '';
+}
+
+function extractReasoningText(details) {
+  const source = Array.isArray(details) ? details : [];
+  return source
+    .map((detail) => {
+      if (typeof detail === 'string') return detail;
+      return typeof detail?.text === 'string' ? detail.text : '';
+    })
+    .join('');
+}
+
+function normalizeReasoningDetails(details) {
+  if (!Array.isArray(details) || details.length === 0) return undefined;
+  const normalized = details
+    .map((detail) => {
+      if (!detail || typeof detail !== 'object') return null;
+      return { ...detail };
+    })
+    .filter(Boolean);
+  return normalized.length > 0 ? normalized : undefined;
+}
+
+function emptyToolCall(index) {
+  return {
+    index,
+    id: '',
+    name: '',
+    arguments: ''
+  };
+}
+
+function isMiniMaxModel(model) {
+  return String(model || '').toLowerCase().includes('minimax');
+}
+
+function normalizeToolCallArguments(argumentsText) {
+  const raw = typeof argumentsText === 'string' ? argumentsText : JSON.stringify(argumentsText ?? {});
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+      return JSON.stringify(parsed);
+    }
+  } catch {}
+  return '{}';
+}
+
+function normalizeIncomingToolCallArguments(argumentsValue) {
+  if (typeof argumentsValue === 'string') return argumentsValue;
+  if (argumentsValue == null) return '{}';
+  try {
+    return JSON.stringify(argumentsValue);
+  } catch {
+    return '{}';
+  }
+}
+
+function sanitizeGatewayMessages(messages) {
+  const source = Array.isArray(messages) ? messages : [];
+  return source
+    .filter((message) => message && typeof message === 'object')
+    .map((message) => {
+      if (!Array.isArray(message.tool_calls) || message.tool_calls.length === 0) {
+        return message;
+      }
+      return {
+        ...message,
+        tool_calls: message.tool_calls.map((toolCall) => ({
+          ...toolCall,
+          function: {
+            ...toolCall?.function,
+            arguments: normalizeToolCallArguments(toolCall?.function?.arguments)
+          }
+        }))
+      };
+    });
+}
+
+function sanitizeMiniMaxMessages(messages) {
+  const source = Array.isArray(messages) ? messages : [];
+  const out = [];
+  let seenNonSystem = false;
+  let keptLeadingSystem = false;
+
+  for (const message of source) {
+    if (!message || typeof message !== 'object') continue;
+    if (message.role === 'system') {
+      if (!seenNonSystem && !keptLeadingSystem) {
+        out.push(message);
+        keptLeadingSystem = true;
+      } else {
+        out.push({
+          role: 'user',
+          content: `[system-note]\n${extractTextContent(message.content)}`
+        });
+      }
+      continue;
+    }
+    seenNonSystem = true;
+    out.push(message);
+  }
+
+  return out;
+}
+
+function buildPayload({ model, temperature, messages, tools, stream = false }) {
+  const sanitizedMessages = sanitizeGatewayMessages(messages);
+  const payload = {
+    model,
+    temperature,
+    messages: isMiniMaxModel(model) ? sanitizeMiniMaxMessages(sanitizedMessages) : sanitizedMessages
+  };
+  if (stream) payload.stream = true;
+  if (Array.isArray(tools) && tools.length > 0) {
+    payload.tools = tools;
+    payload.tool_choice = 'auto';
+  }
+  if (isMiniMaxModel(model)) {
+    payload.extra_body = { reasoning_split: true };
+  }
+  return payload;
+}
+
+function hasTrailingToolContext(messages) {
+  const source = Array.isArray(messages) ? messages : [];
+  for (let index = source.length - 1; index >= 0; index -= 1) {
+    const message = source[index];
+    if (!message || typeof message !== 'object') continue;
+    if (message.role === 'tool') return true;
+    if (message.role === 'assistant' || message.role === 'user') return false;
+  }
+  return false;
+}
+
+function stripMiniMaxThinkContent(text) {
+  const input = String(text || '');
+  if (!input) return '';
+
+  let cursor = 0;
+  let out = '';
+  let removedThink = false;
+
+  while (cursor < input.length) {
+    const openIdx = input.indexOf('<think>', cursor);
+    const closeIdx = input.indexOf('</think>', cursor);
+
+    if (openIdx === -1 && closeIdx === -1) {
+      out += input.slice(cursor);
+      break;
+    }
+
+    if (closeIdx !== -1 && (openIdx === -1 || closeIdx < openIdx)) {
+      removedThink = true;
+      cursor = closeIdx + '</think>'.length;
+      continue;
+    }
+
+    out += input.slice(cursor, openIdx);
+    const closingTagIdx = input.indexOf('</think>', openIdx + '<think>'.length);
+    removedThink = true;
+    if (closingTagIdx === -1) {
+      cursor = input.length;
+      break;
+    }
+    cursor = closingTagIdx + '</think>'.length;
+  }
+
+  return removedThink ? out.trimStart() : out;
+}
+
+function sanitizeMiniMaxText(model, text) {
+  return isMiniMaxModel(model) ? stripMiniMaxThinkContent(text) : text;
+}
+
+function nextMiniMaxVisibleChunk(state, content) {
+  const rawChunk = extractTextContent(content);
+  if (!rawChunk) {
+    return { textDelta: '', nextState: state };
+  }
+
+  const nextRawContent = rawChunk.startsWith(state.rawContent) ? rawChunk : `${state.rawContent}${rawChunk}`;
+  const nextVisibleText = stripMiniMaxThinkContent(nextRawContent);
+  const textDelta = nextVisibleText.startsWith(state.visibleText)
+    ? nextVisibleText.slice(state.visibleText.length)
+    : nextVisibleText;
+
+  return {
+    textDelta,
+    nextState: {
+      rawContent: nextRawContent,
+      visibleText: nextVisibleText
+    }
+  };
+}
+
+function buildAssistantMessage({ text = '', toolCalls = [], content, reasoningDetails }) {
+  const assistantMessage = {
+    role: 'assistant',
+    content: content ?? text
+  };
+  const normalizedReasoningDetails = normalizeReasoningDetails(reasoningDetails);
+  if (normalizedReasoningDetails) {
+    assistantMessage.reasoning_details = normalizedReasoningDetails;
+    assistantMessage.reasoning_content = extractReasoningText(normalizedReasoningDetails);
+  }
+  if (Array.isArray(toolCalls) && toolCalls.length > 0) {
+    assistantMessage.tool_calls = toolCalls.map((tc) => ({
+      id: tc.id,
+      type: 'function',
+      function: {
+        name: tc.name,
+        arguments: tc.arguments || '{}'
+      }
+    }));
+  }
+  return assistantMessage;
+}
+
+function createClient({ baseUrl, apiKey, timeoutMs = 90000, maxRetries = 2 }) {
+  return new OpenAI({
+    apiKey,
+    baseURL: String(baseUrl || '').replace(/\/$/, ''),
+    timeout: timeoutMs,
+    maxRetries
+  });
+}
+
+function buildFinalStreamResult({ text, toolCallsByIndex, usage, messages, reasoningDetails }) {
+  const toolCalls = Array.from(toolCallsByIndex.entries())
+    .sort((a, b) => a[0] - b[0])
+    .map(([, tc], i) => ({
+      id: tc.id || `tc-${i + 1}`,
+      name: tc.name,
+      arguments: tc.arguments || '{}'
+    }))
+    .filter((tc) => tc.name);
+  const normalizedText = String(text || '').trim();
+
+  if (!normalizedText && toolCalls.length === 0) {
+    if (hasTrailingToolContext(messages)) {
+      return {
+        text: '',
+        toolCalls: [],
+        usage,
+        incomplete: true
+      };
+    }
+    throw new Error('Gateway stream returned empty assistant response');
+  }
+
+  return {
+    text,
+    toolCalls,
+    usage,
+    incomplete: false,
+    assistantMessage: buildAssistantMessage({
+      text,
+      toolCalls,
+      reasoningDetails
+    })
+  };
+}
+
+export async function createChatCompletion({
+  baseUrl,
+  apiKey,
+  model,
+  messages,
+  temperature = 0.2,
+  tools,
+  timeoutMs = 90000,
+  maxRetries = 2
+}) {
+  const client = createClient({ baseUrl, apiKey, timeoutMs, maxRetries });
+  const response = await client.chat.completions.create(buildPayload({ model, temperature, messages, tools }));
+  const message = response?.choices?.[0]?.message || {};
+  const text = sanitizeMiniMaxText(model, extractTextContent(message.content));
+  const toolCalls = (message.tool_calls || []).map((tc) => ({
+    id: tc.id,
+    name: tc.function?.name,
+    arguments: normalizeIncomingToolCallArguments(tc.function?.arguments)
+  }));
+  const normalizedText = String(text || '').trim();
+
+  if (!normalizedText && toolCalls.length === 0) {
+    if (hasTrailingToolContext(messages)) {
+      return {
+        text: '',
+        toolCalls: [],
+        usage: response?.usage || null,
+        incomplete: true
+      };
+    }
+    throw new Error('Gateway returned empty assistant response');
+  }
+
+  return {
+    text,
+    toolCalls,
+    usage: response?.usage || null,
+    assistantMessage: buildAssistantMessage({
+      text,
+      toolCalls,
+      content: message.content ?? text,
+      reasoningDetails: message.reasoning_details
+    })
+  };
+}
+
+export async function createChatCompletionStream({
+  baseUrl,
+  apiKey,
+  model,
+  messages,
+  temperature = 0.2,
+  tools,
+  onTextDelta,
+  onToolCallDelta,
+  timeoutMs = 90000,
+  maxRetries = 2
+}) {
+  const client = createClient({ baseUrl, apiKey, timeoutMs, maxRetries });
+  const stream = await client.chat.completions.create(buildPayload({ model, temperature, messages, tools, stream: true }));
+
+  let text = '';
+  let usage = null;
+  const toolCallsByIndex = new Map();
+  let miniMaxStreamState = { rawContent: '', visibleText: '' };
+  let reasoningDetails = [];
+  let previousReasoningText = '';
+
+  for await (const chunk of stream) {
+    usage = chunk?.usage || usage;
+    const choice0 = chunk?.choices?.[0] || {};
+    const delta = choice0?.delta || {};
+    const content = delta.content;
+    const nextReasoningDetails = normalizeReasoningDetails(delta.reasoning_details);
+    if (nextReasoningDetails) {
+      const nextReasoningText = extractReasoningText(nextReasoningDetails);
+      if (nextReasoningText.length >= previousReasoningText.length) {
+        previousReasoningText = nextReasoningText;
+      } else {
+        previousReasoningText += nextReasoningText;
+      }
+      reasoningDetails = previousReasoningText ? [{ type: 'reasoning', text: previousReasoningText }] : reasoningDetails;
+    }
+
+    if (isMiniMaxModel(model)) {
+      const next = nextMiniMaxVisibleChunk(miniMaxStreamState, content);
+      miniMaxStreamState = next.nextState;
+      if (next.textDelta) {
+        text += next.textDelta;
+        if (onTextDelta) onTextDelta(next.textDelta);
+      }
+    } else if (typeof content === 'string' && content.length > 0) {
+      text += content;
+      if (onTextDelta) onTextDelta(content);
+    } else if (Array.isArray(content) && content.length > 0) {
+      const chunkText = extractTextContent(content);
+      if (chunkText) {
+        text += chunkText;
+        if (onTextDelta) onTextDelta(chunkText);
+      }
+    }
+
+    const toolDeltas = Array.isArray(delta.tool_calls) ? delta.tool_calls : [];
+    for (const td of toolDeltas) {
+      const idx = typeof td.index === 'number' ? td.index : 0;
+      const current = toolCallsByIndex.get(idx) || emptyToolCall(idx);
+      if (td.id) current.id = td.id;
+      if (td.function?.name) current.name = `${current.name}${td.function.name}`;
+      if (td.function?.arguments !== undefined) {
+        current.arguments = `${current.arguments}${normalizeIncomingToolCallArguments(td.function.arguments)}`;
+      }
+      toolCallsByIndex.set(idx, current);
+      if (onToolCallDelta) {
+        onToolCallDelta({
+          index: idx,
+          id: current.id || `tc-${idx + 1}`,
+          name: current.name,
+          arguments: current.arguments || '{}'
+        });
+      }
+    }
+
+    if (choice0?.finish_reason) {
+      break;
+    }
+  }
+
+  return buildFinalStreamResult({
+    text,
+    toolCallsByIndex,
+    usage,
+    messages,
+    reasoningDetails
+  });
+}

package/src/core/session-store.js

@@ -41,6 +41,14 @@ function sanitizeMessage(msg) {
   if (msg?.tool_call_id) out.tool_call_id = String(msg.tool_call_id);
   if (typeof msg?.name === 'string' && msg.name.trim()) out.name = msg.name.trim();
   if (typeof msg?.at === 'string' && msg.at.trim()) out.at = msg.at;
+  if (typeof msg?.reasoning_content === 'string' && msg.reasoning_content) {
+    out.reasoning_content = msg.reasoning_content;
+  }
+  if (Array.isArray(msg?.reasoning_details) && msg.reasoning_details.length > 0) {
+    out.reasoning_details = msg.reasoning_details
+      .filter((detail) => detail && typeof detail === 'object')
+      .map((detail) => ({ ...detail }));
+  }
 
   if (Array.isArray(msg?.tool_calls)) {
     const toolCalls = msg.tool_calls.map(sanitizeToolCall).filter(Boolean);

package/src/core/shell-profile.js

@@ -144,13 +144,15 @@ Use update_todos with these rules:
 
 Some tools are loaded on demand through tool_search. Common examples:
 - glob for pattern-based file lookup
-- ast_query and read_ast_node for AST-scoped edits
+- ast_query and read_ast_node for advanced AST-scoped reads and edits
 - generate_diff and patch for explicit diff workflows
 - list_background_tasks, get_background_task, and stop_background_task for managing long-running background commands
 - remember_user, remember_global, remember_project, list_memory, search_memory, and forget_memory for persistent memory operations
 
-For structural code edits (functions, classes, methods), load the AST tools and use the AST-first workflow:
-tool_search("ast_query") → ast_query → read_ast_node → edit with ast_target and kind=replace_block.
+For structural code edits (functions, classes, methods), prefer AST-scoped reads before editing:
+- Common one-shot workflow: read(path, query=..., capture_name=...) → edit with symbol or ast_target
+- If you already have ast_target: read(ast_target=...) → edit with ast_target
+- Advanced multi-step workflow: tool_search("ast_query") → ast_query → read_ast_node → edit with ast_target and kind=replace_block
 Fall back to plain grep/read/edit only when AST is not appropriate.
 
 For background commands: use run to launch. If you need management tools that are not currently visible, load list_background_tasks/get_background_task/stop_background_task with tool_search. Prefer reading the returned output_file with read instead of asking for a separate logs tool.
@@ -192,8 +194,10 @@ Common tool call patterns:
 
 # Tone and style
 
-- Be concise. Go straight to the point
-- Do not restate what the user said
+- Keep answers compact and easy to scan
+- Lead with the answer or next action, not scene-setting
+- Do not restate the user's request unless a brief restatement prevents ambiguity
 - When referencing code, use file_path:line_number format
+- Keep technical wording, commands, paths, and error details exact
 - Only use emojis if the user explicitly requests it`;
 }