sam-coder-cli 1.0.62 → 1.0.64

package/bin/agi-cli.js

@@ -752,6 +752,133 @@ function normalizeToolCallsFromMessage(message) {
   return message;
 }
 
+// Parse segmented format like <|start|>channel<|message|>...<|end|>
+function parseSegmentedTranscript(text) {
+  if (!text || typeof text !== 'string') {
+    return { content: text || '', thought: '', recoveredToolCalls: null, segmented: false };
+  }
+
+  const blockRegex = /\<\|start\|>([^<|]+)\<\|message\|>([\s\S]*?)\<\|end\|>/gi;
+  let match;
+  let visibleParts = [];
+  let thoughts = [];
+  let commentaryParts = [];
+  let segmentedFound = false;
+
+  while ((match = blockRegex.exec(text)) !== null) {
+    const rawRole = (match[1] || '').trim().toLowerCase();
+    const body = (match[2] || '').trim();
+    if (!rawRole) continue;
+    segmentedFound = true;
+
+    if (rawRole === 'analysis') {
+      thoughts.push(body);
+    } else if (rawRole === 'commentary') {
+      commentaryParts.push(body);
+    } else if (rawRole === 'final' || rawRole === 'assistant' || rawRole === 'user' || rawRole === 'system' || rawRole === 'developer') {
+      // Prefer 'final' or 'assistant' as visible, but include others to preserve content order
+      visibleParts.push(body);
+    } else {
+      // Unknown channel: treat as visible content
+      visibleParts.push(body);
+    }
+  }
+
+  // If no blocks matched, return original
+  if (visibleParts.length === 0 && thoughts.length === 0 && commentaryParts.length === 0) {
+    // Try channel-only segments: <|channel|>X [to=Y] [<|constrain|>Z] <|message|>... (<|end|>|<|call|>|<|return|>)
+    const chanRegex = /\<\|channel\|>\s*([a-zA-Z]+)\s*(?:to=([^\s<]+))?\s*(?:\<\|constrain\|>(\w+))?\s*\<\|message\|>([\s\S]*?)(?:\<\|end\|>|\<\|call\|>|\<\|return\|>)/gi;
+    let anyChannel = false;
+    let commsWithRecipients = [];
+    while ((match = chanRegex.exec(text)) !== null) {
+      anyChannel = true;
+      segmentedFound = true;
+      const channel = (match[1] || '').trim().toLowerCase();
+      const recipient = (match[2] || '').trim();
+      const constraint = (match[3] || '').trim().toLowerCase();
+      const body = (match[4] || '').trim();
+      if (channel === 'analysis') {
+        thoughts.push(body);
+      } else if (channel === 'commentary') {
+        if (recipient) {
+          commsWithRecipients.push({ recipient, constraint, body });
+        } else {
+          // preamble visible to user per spec
+          visibleParts.push(body);
+        }
+      } else if (channel === 'final') {
+        visibleParts.push(body);
+      } else {
+        visibleParts.push(body);
+      }
+    }
+    // Build recovered tool calls from commentary with recipients
+    let recoveredToolCalls = null;
+    if (commsWithRecipients.length) {
+      recoveredToolCalls = [];
+      for (const item of commsWithRecipients) {
+        // recipient format like functions.get_weather
+        let funcName = item.recipient;
+        if (funcName.startsWith('functions.')) {
+          funcName = funcName.slice('functions.'.length);
+        }
+        // parse args
+        let args = {};
+        if (item.constraint === 'json' || item.body.startsWith('{') || item.body.startsWith('[')) {
+          try {
+            const parsed = JSON.parse(item.body);
+            args = parsed;
+          } catch (_) {
+            // ignore parse error; leave empty
+          }
+        }
+        recoveredToolCalls.push({
+          id: `inline-${recoveredToolCalls.length + 1}`,
+          type: 'function',
+          function: {
+            name: funcName,
+            arguments: typeof args === 'string' ? args : JSON.stringify(args)
+          }
+        });
+      }
+    }
+
+    if (!anyChannel) {
+      return { content: text, thought: '', recoveredToolCalls: null, segmented: false };
+    }
+    return {
+      content: visibleParts.join('\n\n').trim(),
+      thought: thoughts.join('\n\n').trim(),
+      recoveredToolCalls: recoveredToolCalls && recoveredToolCalls.length ? recoveredToolCalls : null,
+      segmented: segmentedFound
+    };
+  }
+
+  // Look for a Reasoning: level outside blocks as a hint
+  const reasoningMatch = text.match(/Reasoning:\s*(high|medium|low)/i);
+  if (reasoningMatch) {
+    thoughts.unshift(`Reasoning level: ${reasoningMatch[1]}`);
+  }
+
+  // Recover tool calls from commentary channels
+  let recoveredToolCalls = null;
+  if (commentaryParts.length) {
+    for (const part of commentaryParts) {
+      const found = parseInlineToolCalls(part);
+      if (found && found.length) {
+        recoveredToolCalls = (recoveredToolCalls || []).concat(found);
+      }
+    }
+  }
+
+  return {
+    content: visibleParts.join('\n\n').trim(),
+    thought: thoughts.join('\n\n').trim(),
+    recoveredToolCalls: recoveredToolCalls && recoveredToolCalls.length ? recoveredToolCalls : null,
+    segmented: segmentedFound
+  };
+}
+
 // Call OpenRouter API with tool calling
 async function callOpenRouter(messages, currentModel, useJson = false) {
   const apiKey = OPENROUTER_API_KEY;
@@ -810,7 +937,18 @@ async function processQueryWithTools(query, conversation = [], 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);
+      // First handle segmented transcripts, then fallback to <think>
+      const segmented = parseSegmentedTranscript(assistantMessage.content);
+      let thought = segmented.thought;
+      let content = segmented.content;
+      if (!segmented.thought && !segmented.recoveredToolCalls) {
+        const thinkSplit = splitThinking(assistantMessage.content);
+        thought = thought || thinkSplit.thought;
+        content = content || thinkSplit.content;
+      }
+      if (segmented.recoveredToolCalls && (!assistantMessage.tool_calls)) {
+        assistantMessage.tool_calls = segmented.recoveredToolCalls;
+      }
       if (thought && SHOW_THOUGHTS) {
         ui.showThought(thought);
       }
@@ -834,7 +972,14 @@ async function processQueryWithTools(query, conversation = [], currentModel) {
       const finalResponseObj = await callOpenRouter(messages, currentModel);
       const finalAssistantMessage = finalResponseObj.choices[0].message;
       if (finalAssistantMessage && typeof finalAssistantMessage.content === 'string') {
-        const { thought, content } = splitThinking(finalAssistantMessage.content);
+        const segmented = parseSegmentedTranscript(finalAssistantMessage.content);
+        let thought = segmented.thought;
+        let content = segmented.content;
+        if (!segmented.thought && !segmented.recoveredToolCalls) {
+          const thinkSplit = splitThinking(finalAssistantMessage.content);
+          thought = thought || thinkSplit.thought;
+          content = content || thinkSplit.content;
+        }
         if (thought && SHOW_THOUGHTS) {
           ui.showThought(thought);
         }
@@ -859,7 +1004,14 @@ async function processQueryWithTools(query, conversation = [], currentModel) {
           const finalResponseObj = await callOpenRouter(messages, currentModel);
           const finalAssistantMessage = finalResponseObj.choices[0].message;
           if (finalAssistantMessage && typeof finalAssistantMessage.content === 'string') {
-            const { thought, content } = splitThinking(finalAssistantMessage.content);
+            const segmented = parseSegmentedTranscript(finalAssistantMessage.content);
+            let thought = segmented.thought;
+            let content = segmented.content;
+            if (!segmented.thought && !segmented.recoveredToolCalls) {
+              const thinkSplit = splitThinking(finalAssistantMessage.content);
+              thought = thought || thinkSplit.thought;
+              content = content || thinkSplit.content;
+            }
             if (thought && SHOW_THOUGHTS) {
               ui.showThought(thought);
             }
@@ -1001,7 +1153,14 @@ async function processQuery(query, conversation = [], currentModel) {
       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);
+        const segmented = parseSegmentedTranscript(assistantMessage.content);
+        let thought = segmented.thought;
+        let content = segmented.content;
+        if (!segmented.thought && !segmented.recoveredToolCalls) {
+          const thinkSplit = splitThinking(assistantMessage.content);
+          thought = thought || thinkSplit.thought;
+          content = content || thinkSplit.content;
+        }
         if (thought && SHOW_THOUGHTS) {
           ui.showThought(thought);
         }

package/package.json

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