sam-coder-cli 1.0.59 → 1.0.61

package/bin/agi-cli.js

@@ -17,6 +17,7 @@ const CONFIG_PATH = path.join(os.homedir(), '.sam-coder-config.json');
 let OPENROUTER_API_KEY;
 let MODEL = 'deepseek/deepseek-chat-v3-0324:free';
 let API_BASE_URL = 'https://openrouter.ai/api/v1';
+let SHOW_THOUGHTS = false; // Optional: reveal <think> content in console
 
 // Tool/Function definitions for the AI
 const tools = [
@@ -619,6 +620,164 @@ function extractJsonFromMarkdown(text) {
   return null;
 }
 
+// Extract and strip <think>...</think> blocks from model output
+function splitThinking(text) {
+  if (!text || typeof text !== 'string') {
+    return { thought: '', content: text || '' };
+  }
+  const thinkRegex = /<think>[\s\S]*?<\/think>/gi;
+  let combinedThoughts = [];
+  let match;
+  // Collect all thoughts
+  const singleThinkRegex = /<think>([\s\S]*?)<\/think>/i;
+  let remaining = text;
+  while ((match = remaining.match(singleThinkRegex))) {
+    combinedThoughts.push((match[1] || '').trim());
+    remaining = remaining.replace(singleThinkRegex, '');
+  }
+  const visible = remaining.replace(thinkRegex, '').trim();
+  return { thought: combinedThoughts.join('\n\n').trim(), content: visible };
+}
+
+// Try to recover tool/function calls embedded in assistant text for thinking models
+function parseInlineToolCalls(text) {
+  if (!text || typeof text !== 'string') return null;
+
+  const candidates = [];
+
+  // 1) JSON code blocks
+  const codeBlockRegex = /```(?:json)?\s*([\s\S]*?)\s*```/gi;
+  let m;
+  while ((m = codeBlockRegex.exec(text)) !== null) {
+    const block = (m[1] || '').trim();
+    if (block) candidates.push(block);
+  }
+
+  // 2) <tool_call>...</tool_call>
+  const toolTagRegex = /<tool_call>([\s\S]*?)<\/tool_call>/gi;
+  while ((m = toolTagRegex.exec(text)) !== null) {
+    const inner = (m[1] || '').trim();
+    if (inner) candidates.push(inner);
+  }
+  // 2b) <function_call>...</function_call>
+  const fnTagRegex = /<function_call>([\s\S]*?)<\/function_call>/gi;
+  while ((m = fnTagRegex.exec(text)) !== null) {
+    const inner = (m[1] || '').trim();
+    if (inner) candidates.push(inner);
+  }
+
+  // 3) General JSON-looking substrings as last resort
+  const braceRegex = /\{[\s\S]*?\}/g;
+  const braceMatches = text.match(braceRegex) || [];
+  braceMatches.forEach(snippet => candidates.push(snippet));
+
+  const toolCalls = [];
+
+  for (const candidate of candidates) {
+    try {
+      const obj = JSON.parse(candidate);
+      // OpenAI-style single function_call
+      if (obj && obj.function_call && obj.function_call.name) {
+        const args = obj.function_call.arguments ?? {};
+        toolCalls.push({
+          id: `inline-${toolCalls.length + 1}`,
+          type: 'function',
+          function: {
+            name: obj.function_call.name,
+            arguments: typeof args === 'string' ? args : JSON.stringify(args)
+          }
+        });
+        continue;
+      }
+      // Anthropic-like tool_use
+      if (obj && obj.tool_call && obj.tool_call.name) {
+        const args = obj.tool_call.arguments ?? {};
+        toolCalls.push({
+          id: `inline-${toolCalls.length + 1}`,
+          type: 'function',
+          function: {
+            name: obj.tool_call.name,
+            arguments: typeof args === 'string' ? args : JSON.stringify(args)
+          }
+        });
+        continue;
+      }
+      // Array of tool_calls
+      if (Array.isArray(obj?.tool_calls)) {
+        obj.tool_calls.forEach((tc) => {
+          if (tc?.function?.name) {
+            const args = tc.function.arguments ?? {};
+            toolCalls.push({
+              id: tc.id || `inline-${toolCalls.length + 1}`,
+              type: 'function',
+              function: {
+                name: tc.function.name,
+                arguments: typeof args === 'string' ? args : JSON.stringify(args)
+              }
+            });
+          }
+        });
+        if (toolCalls.length) continue;
+      }
+      // Direct function structure
+      if (obj?.name && (obj.arguments !== undefined || obj.args !== undefined)) {
+        const args = obj.arguments ?? obj.args ?? {};
+        toolCalls.push({
+          id: `inline-${toolCalls.length + 1}`,
+          type: 'function',
+          function: {
+            name: obj.name,
+            arguments: typeof args === 'string' ? args : JSON.stringify(args)
+          }
+        });
+        continue;
+      }
+    } catch (_) {
+      // ignore parse failures
+    }
+  }
+
+  return toolCalls.length ? toolCalls : null;
+}
+
+// Normalize single function_call to tool_calls array if present
+function normalizeToolCallsFromMessage(message) {
+  if (!message || typeof message !== 'object') return message;
+  if (!message.tool_calls && message.function_call && message.function_call.name) {
+    const args = message.function_call.arguments ?? {};
+    message.tool_calls = [{
+      id: 'fc-1',
+      type: 'function',
+      function: {
+        name: message.function_call.name,
+        arguments: typeof args === 'string' ? args : JSON.stringify(args)
+      }
+    }];
+  }
+  return message;
+}
+
+// Ask the model to produce a structured follow-up with thinking and either tool_calls or JSON action
+async function requestStructuredFollowup(messages, currentModel, preferTools = true) {
+  const instruction = preferTools
+    ? 'Think step-by-step inside <think></think>. Then, if any tools are needed, call them via tool_calls. If no tools are required, output a single markdown ```json code block with an action object (type, data, reasoning) per the schema. Do not include any other text.'
+    : 'Think step-by-step inside <think></think>, then output a single markdown ```json code block with an action object (type, data, reasoning) per the schema. Do not include any other text.';
+
+  const followupUser = { role: 'user', content: instruction };
+  const followupMessages = [...messages, followupUser];
+  const responseObj = await callOpenRouter(followupMessages, currentModel, !preferTools);
+  const assistantMessage = responseObj.choices[0].message;
+  if (assistantMessage && typeof assistantMessage.content === 'string') {
+    const { thought, content } = splitThinking(assistantMessage.content);
+    if (thought && SHOW_THOUGHTS) {
+      ui.showInfo(`Thinking:\n${thought}`);
+    }
+    assistantMessage.content = content;
+  }
+  normalizeToolCallsFromMessage(assistantMessage);
+  return { assistantMessage, updatedMessages: [...followupMessages, assistantMessage] };
+}
+
 // Call OpenRouter API with tool calling
 async function callOpenRouter(messages, currentModel, useJson = false) {
   const apiKey = OPENROUTER_API_KEY;
@@ -675,8 +834,24 @@ async function processQueryWithTools(query, conversation = [], currentModel) {
   try {
     const response = await callOpenRouter(messages, currentModel);
     const assistantMessage = response.choices[0].message;
+    // Handle thinking tags and optionally display them
+    if (assistantMessage && typeof assistantMessage.content === 'string') {
+      const { thought, content } = splitThinking(assistantMessage.content);
+      if (thought && SHOW_THOUGHTS) {
+        ui.showInfo(`Thinking:\n${thought}`);
+      }
+      assistantMessage.content = content;
+    }
+    normalizeToolCallsFromMessage(assistantMessage);
     messages.push(assistantMessage);
 
+    // Try inline recovery for thinking models that embed tool calls inside content
+    if (!assistantMessage.tool_calls && assistantMessage.content) {
+      const recovered = parseInlineToolCalls(assistantMessage.content);
+      if (recovered && recovered.length) {
+        assistantMessage.tool_calls = recovered;
+      }
+    }
     if (assistantMessage.tool_calls) {
       const toolResults = await handleToolCalls(assistantMessage.tool_calls, messages);
       messages.push(...toolResults);
@@ -684,6 +859,14 @@ async function processQueryWithTools(query, conversation = [], currentModel) {
       ui.startThinking();
       const finalResponseObj = await callOpenRouter(messages, currentModel);
       const finalAssistantMessage = finalResponseObj.choices[0].message;
+      if (finalAssistantMessage && typeof finalAssistantMessage.content === 'string') {
+        const { thought, content } = splitThinking(finalAssistantMessage.content);
+        if (thought && SHOW_THOUGHTS) {
+          ui.showInfo(`Thinking:\n${thought}`);
+        }
+        finalAssistantMessage.content = content;
+      }
+      normalizeToolCallsFromMessage(finalAssistantMessage);
       messages.push(finalAssistantMessage);
       ui.stopThinking();
 
@@ -692,6 +875,82 @@ async function processQueryWithTools(query, conversation = [], currentModel) {
         conversation: messages
       };
     } else {
+      // Fallback: if no tool_calls were returned, try to parse a JSON action from content (thinking models may embed later)
+      const fallbackAction = extractJsonFromMarkdown(assistantMessage.content);
+      if (fallbackAction && fallbackAction.type) {
+        try {
+          const result = await executeAction(fallbackAction);
+          messages.push({ role: 'user', content: `Action result (${fallbackAction.type}): ${result}` });
+          ui.startThinking();
+          const finalResponseObj = await callOpenRouter(messages, currentModel);
+          const finalAssistantMessage = finalResponseObj.choices[0].message;
+          if (finalAssistantMessage && typeof finalAssistantMessage.content === 'string') {
+            const { thought, content } = splitThinking(finalAssistantMessage.content);
+            if (thought && SHOW_THOUGHTS) {
+              ui.showInfo(`Thinking:\n${thought}`);
+            }
+            finalAssistantMessage.content = content;
+          }
+          normalizeToolCallsFromMessage(finalAssistantMessage);
+          messages.push(finalAssistantMessage);
+          ui.stopThinking();
+          return { response: finalAssistantMessage.content, conversation: messages };
+        } catch (e) {
+          ui.stopThinking();
+          // If fallback execution fails, just return original assistant content
+        }
+      }
+      // Final attempt: request a structured follow-up that includes thinking and tool calls
+      try {
+        ui.startThinking();
+        const { assistantMessage: structuredMsg, updatedMessages } = await requestStructuredFollowup(messages, currentModel, true);
+        messages.length = 0; updatedMessages.forEach(m => messages.push(m));
+
+        // If tool calls present now, execute them
+        if (structuredMsg.tool_calls && structuredMsg.tool_calls.length) {
+          const toolResults2 = await handleToolCalls(structuredMsg.tool_calls, messages);
+          messages.push(...toolResults2);
+          const finalResponseObj2 = await callOpenRouter(messages, currentModel);
+          const finalAssistantMessage2 = finalResponseObj2.choices[0].message;
+          if (finalAssistantMessage2 && typeof finalAssistantMessage2.content === 'string') {
+            const { thought, content } = splitThinking(finalAssistantMessage2.content);
+            if (thought && SHOW_THOUGHTS) ui.showInfo(`Thinking:\n${thought}`);
+            finalAssistantMessage2.content = content;
+          }
+          messages.push(finalAssistantMessage2);
+          ui.stopThinking();
+          return { response: finalAssistantMessage2.content, conversation: messages };
+        }
+
+        // Else try JSON action again from the structured response
+        const structuredAction = extractJsonFromMarkdown(structuredMsg.content);
+        if (structuredAction && structuredAction.type) {
+          try {
+            const result2 = await executeAction(structuredAction);
+            messages.push({ role: 'user', content: `Action result (${structuredAction.type}): ${result2}` });
+            const finalResponseObj3 = await callOpenRouter(messages, currentModel);
+            const finalAssistantMessage3 = finalResponseObj3.choices[0].message;
+            if (finalAssistantMessage3 && typeof finalAssistantMessage3.content === 'string') {
+              const { thought, content } = splitThinking(finalAssistantMessage3.content);
+              if (thought && SHOW_THOUGHTS) ui.showInfo(`Thinking:\n${thought}`);
+              finalAssistantMessage3.content = content;
+            }
+            messages.push(finalAssistantMessage3);
+            ui.stopThinking();
+            return { response: finalAssistantMessage3.content, conversation: messages };
+          } catch (_) {
+            ui.stopThinking();
+          }
+        }
+
+        ui.stopThinking();
+        return {
+          response: structuredMsg.content,
+          conversation: messages
+        };
+      } catch (_) {
+        // ignore and fall back to original assistant message
+      }
       ui.stopThinking();
       return {
         response: assistantMessage.content,
@@ -818,6 +1077,14 @@ async function processQuery(query, conversation = [], currentModel) {
     while (actionCount < MAX_ACTIONS) {
       const responseObj = await callOpenRouter(messages, currentModel, true);
       const assistantMessage = responseObj.choices[0].message;
+      if (assistantMessage && typeof assistantMessage.content === 'string') {
+        const { thought, content } = splitThinking(assistantMessage.content);
+        if (thought && SHOW_THOUGHTS) {
+          ui.showInfo(`Thinking:\n${thought}`);
+        }
+        assistantMessage.content = content;
+      }
+      normalizeToolCallsFromMessage(assistantMessage);
       messages.push(assistantMessage);
       
       const actionData = extractJsonFromMarkdown(assistantMessage.content);
@@ -869,8 +1136,17 @@ async function processQuery(query, conversation = [], currentModel) {
       messages.push(finalMsg);
       
       const finalResponseObj = await callOpenRouter(messages, currentModel, true);
-      finalResponse = finalResponseObj.choices[0].message.content;
-      messages.push(finalResponseObj.choices[0].message);
+      const finalAssistantMessage = finalResponseObj.choices[0].message;
+      if (finalAssistantMessage && typeof finalAssistantMessage.content === 'string') {
+        const { thought, content } = splitThinking(finalAssistantMessage.content);
+        if (thought && SHOW_THOUGHTS) {
+          ui.showInfo(`Thinking:\n${thought}`);
+        }
+        finalResponse = content;
+      } else {
+        finalResponse = finalResponseObj.choices[0].message.content;
+      }
+      messages.push(finalAssistantMessage);
     }
 
     ui.stopThinking();
@@ -920,6 +1196,25 @@ async function chat(rl, useToolCalling, initialModel) {
       return;
     }
 
+    if (input.toLowerCase().startsWith('/thoughts')) {
+      const parts = input.trim().split(/\s+/);
+      const arg = parts[1] ? parts[1].toLowerCase() : '';
+      if (arg !== 'on' && arg !== 'off') {
+        const state = SHOW_THOUGHTS ? 'on' : 'off';
+        ui.showInfo(`Usage: /thoughts on|off (currently ${state})`);
+        rl.prompt();
+        return;
+      }
+      const enable = arg === 'on';
+      SHOW_THOUGHTS = enable;
+      let config = await readConfig() || {};
+      config.showThoughts = enable;
+      await writeConfig(config);
+      ui.showResponse(`Hidden thoughts ${enable ? 'enabled' : 'disabled'}.`);
+      rl.prompt();
+      return;
+    }
+
     if (input.toLowerCase() === '/default-model') {
       currentModel = 'deepseek/deepseek-chat-v3-0324:free';
       let config = await readConfig() || {};
@@ -1039,6 +1334,9 @@ async function start() {
       console.log(`🚀 Using Pro Plan custom endpoint: ${API_BASE_URL}`);
     }
 
+    // Optional: reveal <think> thoughts if enabled in config or env
+    SHOW_THOUGHTS = (typeof config.showThoughts === 'boolean') ? config.showThoughts : (process.env.SHOW_THOUGHTS === '1');
+
     // Check if animation should be shown (can be disabled via config)
     const showAnimation = config.showAnimation !== false; // Default to true
     

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sam-coder-cli",
-  "version": "1.0.59",
+  "version": "1.0.61",
   "description": "SAM-CODER: An animated command-line AI assistant with agency capabilities.",
   "main": "bin/agi-cli.js",
   "bin": {