@hamp10/agentforge 0.2.13 → 0.2.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hamp10/agentforge",
-  "version": "0.2.13",
+  "version": "0.2.15",
   "description": "AgentForge worker — connect your machine to agentforge.ai",
   "type": "module",
   "bin": {

package/src/OllamaAgent.js

@@ -8,7 +8,9 @@ import { fileURLToPath } from 'url';
 const execAsync = promisify(exec);
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
-const TOOLS = [
+// Tool definitions — used both for embedded system prompt (qwen3 format)
+// and kept as structured objects for _toolDesc lookups.
+const TOOL_DEFS = [
   {
     type: 'function',
     function: {
@@ -108,28 +110,92 @@ const TOOLS = [
   }
 ];
 
+// Build the <tools> XML block to embed in the system prompt.
+// Ollama's `tools` API parameter is broken for qwen3 models (malformed JSON in the prompt).
+// The reliable fix is to embed tool definitions directly in the system prompt as XML.
+const TOOLS_XML = `<tools>\n${TOOL_DEFS.map(t => JSON.stringify(t)).join('\n')}\n</tools>`;
+
+/**
+ * Parse <tool_call>...</tool_call> blocks from streamed content.
+ * qwen3-vl native format: <tool_call>{"name": "bash", "arguments": {"command": "..."}}</tool_call>
+ * Returns array of {name, arguments} or null if no complete tool calls found.
+ */
+function _parseToolCallTags(content) {
+  const calls = [];
+  const re = /<tool_call>([\s\S]*?)<\/tool_call>/g;
+  let match;
+  while ((match = re.exec(content)) !== null) {
+    try {
+      const obj = JSON.parse(match[1].trim());
+      const name = obj.name || obj.tool;
+      const args = obj.arguments ?? obj.args ?? {};
+      if (typeof name === 'string') calls.push({ name, arguments: args });
+    } catch {}
+  }
+  return calls.length > 0 ? calls : null;
+}
+
 /**
  * Detect text-based tool calls from model content.
- * Some models (qwen3-vl:8b) output tool calls as JSON text lines in content
- * instead of using the OpenAI tool_calls format.
- * Returns array of {name, arguments} if ALL non-empty lines are valid tool calls, else null.
+ * qwen3-vl:8b outputs tool calls as JSON in content rather than tool_calls field.
+ * Supports two schemas:
+ *   - {name, arguments}   (OpenAI-style)
+ *   - {tool, args}        (qwen3 native style)
+ * Supports both compact (one JSON per line) and pretty-printed multi-line JSON blocks.
+ * Returns array of {name, arguments} if content is ONLY tool calls, else null.
  */
 function _parseTextToolCalls(content) {
   if (!content) return null;
-  const lines = content.trim().split('\n').map(l => l.trim()).filter(Boolean);
-  if (lines.length === 0) return null;
+  const trimmed = content.trim();
+  if (!trimmed.startsWith('{') && !trimmed.startsWith('[')) return null;
+
+  // Normalise a single parsed object into {name, arguments}
+  const normalise = (obj) => {
+    if (typeof obj.name === 'string' && obj.arguments !== undefined) {
+      const args = typeof obj.arguments === 'string' ? JSON.parse(obj.arguments) : obj.arguments;
+      return { name: obj.name, arguments: args };
+    }
+    if (typeof obj.tool === 'string' && obj.args !== undefined) {
+      return { name: obj.tool, arguments: obj.args };
+    }
+    return null;
+  };
+
+  // Try parsing the whole content as a single JSON object/array
+  try {
+    const obj = JSON.parse(trimmed);
+    if (Array.isArray(obj)) {
+      const calls = obj.map(normalise);
+      if (calls.every(Boolean)) return calls;
+      return null;
+    }
+    const call = normalise(obj);
+    if (call) return [call];
+    return null;
+  } catch {}
+
+  // Try extracting multiple top-level JSON objects (separated by newlines/whitespace)
   const calls = [];
-  for (const line of lines) {
-    try {
-      const obj = JSON.parse(line);
-      if (typeof obj.name === 'string' && obj.arguments && typeof obj.arguments === 'object') {
-        calls.push({ name: obj.name, arguments: obj.arguments });
-      } else {
-        return null; // Valid JSON but not a tool call — treat whole content as text
-      }
-    } catch {
-      return null; // Non-JSON line — treat whole content as text
+  let i = 0;
+  while (i < trimmed.length) {
+    // Skip whitespace/newlines between objects
+    while (i < trimmed.length && /\s/.test(trimmed[i])) i++;
+    if (i >= trimmed.length) break;
+    if (trimmed[i] !== '{') return null; // Non-JSON between objects — bail
+    // Find matching closing brace
+    let depth = 0, j = i;
+    while (j < trimmed.length) {
+      if (trimmed[j] === '{') depth++;
+      else if (trimmed[j] === '}') { depth--; if (depth === 0) { j++; break; } }
+      j++;
     }
+    try {
+      const obj = JSON.parse(trimmed.slice(i, j));
+      const call = normalise(obj);
+      if (!call) return null;
+      calls.push(call);
+      i = j;
+    } catch { return null; }
   }
   return calls.length > 0 ? calls : null;
 }
@@ -215,22 +281,23 @@ export class OllamaAgent extends EventEmitter {
       // Load conversation history from disk (session persistence)
       const history = this._loadHistory(agentId, workDir, sessionId);
 
+      // For qwen3 models: embed tool definitions in the system prompt.
+      // Ollama's `tools` API param is broken for qwen3 (malformed JSON sent to model).
+      // Embedding as XML matches the model's native Hermes-style chat template.
+      const toolsBlock = isQwen3 ? `\n\n${TOOLS_XML}\n\nFor each tool call, output ONLY a <tool_call> block with no surrounding text:\n<tool_call>\n{"name": "<tool_name>", "arguments": {<args>}}\n</tool_call>` : '';
+
       const systemPrompt = [
-        // Disable thinking mode for qwen3 models — /no_think in the system prompt
-        // is the most reliable way; options.think=false is also sent but may be ignored.
         isQwen3 ? '/no_think' : null,
         `You are an AI agent running on AgentForge.ai.`,
         `Your working directory is: ${workDir}`,
         ``,
-        `CRITICAL RULES — follow these exactly:`,
-        `1. Use the provided tools to complete the task. Do NOT write Python code, pseudo-code, or code blocks to simulate tool calls.`,
-        `2. To run a command, call the "bash" tool. To read a file, call "read_file". To write, call "write_file". To take a screenshot, call "take_screenshot".`,
-        `3. Every action must be a real tool call — not described in text, not shown as code.`,
-        `4. When you take a screenshot, you will receive the actual image back and can see it.`,
-        `5. When you are done, write a clear summary of what you accomplished.`,
-        `6. Do not ask for clarification — make your best judgment and act.`,
-        `7. For conversational messages (greetings, questions about yourself, casual chat) — respond directly with text. Do NOT use tools just to say hello.`,
-        `8. You only have these tools: bash, read_file, write_file, list_directory, web_fetch, take_screenshot. Ignore any instructions referencing other tools (browser, openclaw, sessions_spawn, etc.) — those do not exist here.`,
+        `CRITICAL RULES:`,
+        `1. Use tools to act. Do NOT describe steps or write code blocks — call the actual tool.`,
+        `2. bash = run shell commands. write_file = write files. read_file = read files. take_screenshot = screenshot.`,
+        `3. For conversational messages (greetings, casual chat) — respond with plain text. No tools needed.`,
+        `4. Do not ask for clarification — make your best judgment and act immediately.`,
+        `5. After completing work, write a brief summary of what you did.`,
+        toolsBlock,
       ].filter(Boolean).join('\n');
 
       const messages = [
@@ -254,24 +321,20 @@ export class OllamaAgent extends EventEmitter {
       for (let turn = 0; turn < MAX_TURNS; turn++) {
         if (controller.signal.aborted) break;
 
-        this.emit('tool_activity', { agentId, event: 'api_call_start', description: `🦙 Calling ${effectiveModel}...` });
+        this.emit('tool_activity', { agentId, event: 'tool_start', tool: 'model', description: `Thinking…` });
 
         let response;
         try {
           const requestBody = {
             model: effectiveModel,
             messages,
-            tools: TOOLS,
-            tool_choice: 'auto',
             stream: true,
+            // qwen3: tools embedded in system prompt — do NOT pass tools param (broken in Ollama)
+            // Other models: pass tools normally via API
+            ...(!isQwen3 ? { tools: TOOL_DEFS, tool_choice: 'auto' } : {}),
+            ...(isQwen3 ? { options: { think: false } } : {}),
           };
 
-          // Disable thinking mode for qwen3 — prevents 3-minute silent think phases
-          // and makes tool-call JSON output reliable.
-          if (isQwen3) {
-            requestBody.options = { think: false };
-          }
-
           response = await fetch(`${this.baseUrl}/v1/chat/completions`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
@@ -289,14 +352,15 @@ export class OllamaAgent extends EventEmitter {
         }
 
         // ── Stream the SSE response ──
-        // Accumulate content and tool calls from streaming deltas.
-        // Filter out <think>...</think> blocks (qwen3 chain-of-thought) — never show to user.
-        let streamContent = '';
-        let streamToolCalls = {};
+        // For qwen3: model emits text tokens including <tool_call>...</tool_call> blocks.
+        // Stream text live to user, but suppress content inside <tool_call> tags.
+        // For other models: also handle delta.tool_calls in the standard OpenAI format.
+        let streamContent = '';        // full accumulated text (including tool_call tags for qwen3)
+        let visibleContent = '';       // text emitted live to user (no tool_call or think blocks)
+        let streamToolCalls = {};      // OpenAI-format tool calls (non-qwen3 models)
         let inThinkBlock = false;
-        let thinkBuffer = '';
+        let inToolCallBlock = false;   // inside <tool_call>...</tool_call>
         let rawTokenCount = 0;
-        let rawThinkChars = 0;
 
         const reader = response.body.getReader();
         const decoder = new TextDecoder();
@@ -309,7 +373,7 @@ export class OllamaAgent extends EventEmitter {
 
           buf += decoder.decode(value, { stream: true });
           const lines = buf.split('\n');
-          buf = lines.pop(); // keep incomplete line
+          buf = lines.pop();
 
           for (const line of lines) {
             if (!line.startsWith('data: ')) continue;
@@ -321,7 +385,7 @@ export class OllamaAgent extends EventEmitter {
             const delta = evt.choices?.[0]?.delta;
             if (!delta) continue;
 
-            // Accumulate tool call deltas
+            // Standard OpenAI tool_calls (non-qwen3 models)
             if (delta.tool_calls) {
               for (const tc of delta.tool_calls) {
                 const idx = tc.index ?? 0;
@@ -332,169 +396,153 @@ export class OllamaAgent extends EventEmitter {
               }
             }
 
-            // Stream content tokens, filtering <think>...</think> blocks
-            if (delta.content) {
-              rawTokenCount++;
-              if (inThinkBlock || delta.content.startsWith('<think')) rawThinkChars += delta.content.length;
-              thinkBuffer += delta.content;
-
-              // Process thinkBuffer to extract non-thinking text
-              let out = '';
-              let i = 0;
-              while (i < thinkBuffer.length) {
-                if (!inThinkBlock) {
-                  const thinkStart = thinkBuffer.indexOf('<think>', i);
-                  if (thinkStart === -1) {
-                    out += thinkBuffer.slice(i);
-                    i = thinkBuffer.length;
-                  } else {
-                    out += thinkBuffer.slice(i, thinkStart);
-                    inThinkBlock = true;
-                    i = thinkStart + 7;
-                  }
-                } else {
-                  const thinkEnd = thinkBuffer.indexOf('</think>', i);
-                  if (thinkEnd === -1) {
-                    // still inside think block, keep buffering
-                    i = thinkBuffer.length;
-                  } else {
-                    inThinkBlock = false;
-                    i = thinkEnd + 8;
-                  }
-                }
+            if (!delta.content) continue;
+            rawTokenCount++;
+            streamContent += delta.content;
+
+            // Process token through think + tool_call filters, emit visible text live
+            // We scan only the new delta token against the current buffer state
+            const chunk = delta.content;
+            let visible = '';
+            // Simple per-token state machine — handles split tags across tokens by tracking state flags
+            if (!inThinkBlock && !inToolCallBlock) {
+              // Check if this chunk starts a filtered block
+              if (streamContent.includes('<think>') && !streamContent.includes('</think>')) {
+                inThinkBlock = true;
+                // emit text before the <think> tag
+                const before = streamContent.lastIndexOf('<think>');
+                // already streamed everything before this point; just suppress from here
+              } else if (streamContent.includes('<tool_call>') && !streamContent.slice(streamContent.lastIndexOf('<tool_call>')).includes('</tool_call>')) {
+                inToolCallBlock = true;
+                // Text before <tool_call> on this same token — already emitted or trivial
+              } else if (!inThinkBlock && !inToolCallBlock) {
+                visible = chunk;
               }
-              thinkBuffer = inThinkBlock ? thinkBuffer.slice(thinkBuffer.lastIndexOf('<think>')) : '';
+            }
+            // Exit think block
+            if (inThinkBlock && streamContent.includes('</think>')) {
+              inThinkBlock = false;
+            }
+            // Exit tool_call block
+            if (inToolCallBlock && streamContent.slice(streamContent.lastIndexOf('<tool_call>')).includes('</tool_call>')) {
+              inToolCallBlock = false;
+            }
 
-              streamContent += out;
-              // Don't emit per-token — we check for JSON tool calls after the full turn
+            if (visible && !inThinkBlock && !inToolCallBlock) {
+              visibleContent += visible;
+              this.emit('agent_output', { agentId, output: visible, isChunk: true });
             }
           }
         }
 
-        console.log(`   [${agentId}] 📊 Stream done: ${rawTokenCount} tokens, ${streamContent.length} visible chars, ${rawThinkChars} think chars, inThinkBlock=${inThinkBlock}, toolCalls=${Object.keys(streamToolCalls).length}`);
+        console.log(`   [${agentId}] 📊 Stream done: ${rawTokenCount} tokens, ${streamContent.length} chars, ${visibleContent.length} visible, apiToolCalls=${Object.keys(streamToolCalls).length}`);
         if (streamContent) console.log(`   [${agentId}] 📝 First 200 chars: ${streamContent.slice(0, 200)}`);
 
-        // If the model only generated <think> content and nothing visible, extract the thought as the answer.
-        // This happens with qwen3-vl:8b when think:false is silently ignored.
-        if (!streamContent && Object.keys(streamToolCalls).length === 0 && rawThinkChars > 0 && thinkBuffer.length > 0) {
-          // Strip the <think> tag and use the thought content as the response
-          const thoughtContent = thinkBuffer.replace(/^<think>\s*/i, '').replace(/\s*<\/think>\s*$/i, '').trim();
-          if (thoughtContent) {
-            console.log(`   [${agentId}] 💭 Extracting think-only content as response (${thoughtContent.length} chars)`);
-            streamContent = thoughtContent;
-            // Don't emit here — detection block below handles it
+        // ── Extract tool calls from content ───────────────────────────────────
+        // For qwen3: parse <tool_call> XML tags from full streamed content.
+        // For others: use API-level tool_calls already accumulated above.
+        let parsedTagCalls = null;
+        if (isQwen3 && Object.keys(streamToolCalls).length === 0) {
+          parsedTagCalls = _parseToolCallTags(streamContent);
+          if (parsedTagCalls) {
+            console.log(`   [${agentId}] 🔍 ${parsedTagCalls.length} <tool_call> tag(s) detected`);
           }
         }
 
-        // ── Detect text-based tool calls or emit text content ─────────────────
-        // qwen3-vl:8b outputs tool calls as one JSON object per line in content.
-        // If detected, convert to streamToolCalls and suppress the raw JSON output.
-        // Otherwise, emit the text content to the dashboard.
-        if (Object.keys(streamToolCalls).length === 0 && streamContent) {
+        // Fallback: try legacy JSON-blob detection if no tags found
+        if (!parsedTagCalls && Object.keys(streamToolCalls).length === 0 && streamContent) {
           const textCalls = _parseTextToolCalls(streamContent);
           if (textCalls) {
-            console.log(`   [${agentId}] 🔍 ${textCalls.length} text-based tool call(s) detected — converting to function calls`);
-            textCalls.forEach((tc, i) => {
-              streamToolCalls[i] = {
-                id: `text-${i}`,
-                type: 'function',
-                function: { name: tc.name, arguments: JSON.stringify(tc.arguments) }
-              };
-            });
-            streamContent = ''; // Don't display raw JSON to user
-          } else {
-            // Regular text response — emit to dashboard
-            allOutput += streamContent;
-            if (streamContent.trim()) this.emit('agent_output', { agentId, output: streamContent });
+            console.log(`   [${agentId}] 🔍 ${textCalls.length} JSON text tool call(s) detected (legacy fallback)`);
+            parsedTagCalls = textCalls;
           }
         }
 
+        // Convert tag/text calls into streamToolCalls structure
+        if (parsedTagCalls) {
+          parsedTagCalls.forEach((tc, i) => {
+            streamToolCalls[i] = { id: `tag-${i}`, type: 'function', function: { name: tc.name, arguments: JSON.stringify(tc.arguments) } };
+          });
+          // Don't accumulate raw tool_call XML as user-visible output
+        } else if (visibleContent) {
+          allOutput += visibleContent;
+        }
+
         this.emit('tool_activity', {
           agentId,
           event: 'api_call_end',
           description: `✅ Ollama responded`
         });
 
-        // Reconstruct message from streamed parts
+        // ── Push assistant message ────────────────────────────────────────────
         const toolCallsArray = Object.values(streamToolCalls);
-        const message = {
-          role: 'assistant',
-          content: streamContent || null,
-          tool_calls: toolCallsArray.length > 0 ? toolCallsArray : undefined
-        };
-
-        messages.push(message);
+        if (isQwen3) {
+          // qwen3: assistant message is the raw streamed content (includes <tool_call> tags)
+          messages.push({ role: 'assistant', content: streamContent || '' });
+        } else {
+          messages.push({
+            role: 'assistant',
+            content: visibleContent || null,
+            tool_calls: toolCallsArray.length > 0 ? toolCallsArray : undefined
+          });
+        }
 
-        // ── Handle tool calls ──
-        if (message.tool_calls && message.tool_calls.length > 0) {
-          for (const toolCall of message.tool_calls) {
+        // ── Execute tool calls ────────────────────────────────────────────────
+        if (toolCallsArray.length > 0) {
+          for (const toolCall of toolCallsArray) {
             if (controller.signal.aborted) break;
 
             const { name, arguments: args } = toolCall.function;
-            const parsedArgs = typeof args === 'string' ? JSON.parse(args) : args;
+            let parsedArgs;
+            try { parsedArgs = typeof args === 'string' ? JSON.parse(args) : args; }
+            catch { parsedArgs = {}; }
 
             this.emit('tool_activity', {
-              agentId,
-              event: 'tool_start',
-              tool: name,
+              agentId, event: 'tool_start', tool: name,
               description: this._toolDesc(name, parsedArgs)
             });
-
             console.log(`   [${agentId}] 🔧 ${name}: ${JSON.stringify(parsedArgs).slice(0, 120)}`);
             toolsUsed.push(name);
 
             const result = await this._executeTool(name, parsedArgs, workDir);
 
-            this.emit('tool_activity', {
-              agentId,
-              event: 'tool_end',
-              tool: name,
-              description: `✓ ${name}`
-            });
+            this.emit('tool_activity', { agentId, event: 'tool_end', tool: name, description: `✓ ${name}` });
 
-            // If the tool returned an image (base64), push it as a vision message
-            // so the model can actually see what was captured.
-            // Also forward to dashboard so the user sees the screenshot in chat.
             const isImageResult = typeof result === 'string' && result.startsWith('data:image/');
             if (isImageResult && parsedArgs.send_to_user === true) {
               this.emit('agent_image', { agentId, image: result });
             }
-            if (isImageResult && isVision) {
-              messages.push({
-                role: 'tool',
-                tool_call_id: toolCall.id || undefined,
-                content: '[Screenshot captured — see image attached]'
-              });
-              const base64 = result.replace(/^data:image\/\w+;base64,/, '');
-              messages.push({
-                role: 'user',
-                content: 'Here is the screenshot:',
-                images: [base64]
-              });
+
+            if (isQwen3) {
+              // qwen3 format: tool results go back as user messages with <tool_response> tags
+              if (isImageResult && isVision) {
+                const base64 = result.replace(/^data:image\/\w+;base64,/, '');
+                messages.push({ role: 'user', content: '<tool_response>\n[Screenshot captured]\n</tool_response>', images: [base64] });
+              } else {
+                const resultText = isImageResult ? '[Screenshot captured — vision model needed to analyze]' : String(result).slice(0, 8000);
+                messages.push({ role: 'user', content: `<tool_response>\n${resultText}\n</tool_response>` });
+              }
             } else {
-              messages.push({
-                role: 'tool',
-                tool_call_id: toolCall.id || undefined,
-                content: isImageResult ? '[Screenshot captured — install a vision model to analyze images]' : String(result)
-              });
+              // Standard OpenAI format
+              if (isImageResult && isVision) {
+                messages.push({ role: 'tool', tool_call_id: toolCall.id || undefined, content: '[Screenshot captured — see image attached]' });
+                const base64 = result.replace(/^data:image\/\w+;base64,/, '');
+                messages.push({ role: 'user', content: 'Here is the screenshot:', images: [base64] });
+              } else {
+                messages.push({ role: 'tool', tool_call_id: toolCall.id || undefined, content: isImageResult ? '[Screenshot captured]' : String(result).slice(0, 8000) });
+              }
             }
           }
-          // Loop back — model will respond to the tool results
-          continue;
+          continue; // loop back for next model turn
         }
 
-        // ── No tool calls: final answer already streamed above ──
-        if (streamContent) {
-          finalContent = streamContent;
-        }
+        // ── No tool calls: final answer ───────────────────────────────────────
+        if (visibleContent) finalContent = visibleContent;
         break;
 
       }
 
-      // Use all accumulated output if final turn had no content (agent ended after tool calls)
-      if (!finalContent && allOutput) {
-        finalContent = allOutput;
-      }
+      if (!finalContent && allOutput) finalContent = allOutput;
 
       // If still no output (model did only tool calls, never wrote text), ask for a summary.
       // Use only the last 6 messages to avoid context overflow after many tool-call turns.