@hamp10/agentforge 0.2.8 → 0.2.10

package/package.json

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

package/src/OllamaAgent.js

@@ -104,6 +104,32 @@ const TOOLS = [
   }
 ];
 
+/**
+ * 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.
+ */
+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 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
+    }
+  }
+  return calls.length > 0 ? calls : null;
+}
+
 /**
  * LocalModelAgent — drop-in replacement for OpenClawCLI.
  * Runs an agentic tool-use loop against ANY OpenAI-compatible local model server.
@@ -186,6 +212,9 @@ export class OllamaAgent extends EventEmitter {
       const history = this._loadHistory(agentId, workDir, sessionId);
 
       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}`,
         ``,
@@ -198,7 +227,7 @@ export class OllamaAgent extends EventEmitter {
         `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.`,
-      ].join('\n');
+      ].filter(Boolean).join('\n');
 
       const messages = [
         { role: 'system', content: systemPrompt },
@@ -262,6 +291,8 @@ export class OllamaAgent extends EventEmitter {
         let streamToolCalls = {};
         let inThinkBlock = false;
         let thinkBuffer = '';
+        let rawTokenCount = 0;
+        let rawThinkChars = 0;
 
         const reader = response.body.getReader();
         const decoder = new TextDecoder();
@@ -299,6 +330,8 @@ 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
@@ -329,14 +362,49 @@ export class OllamaAgent extends EventEmitter {
               thinkBuffer = inThinkBlock ? thinkBuffer.slice(thinkBuffer.lastIndexOf('<think>')) : '';
 
               streamContent += out;
-              allOutput += out;
-              if (out) {
-                this.emit('agent_output', { agentId, output: out });
-              }
+              // Don't emit per-token — we check for JSON tool calls after the full turn
             }
           }
         }
 
+        console.log(`   [${agentId}] 📊 Stream done: ${rawTokenCount} tokens, ${streamContent.length} visible chars, ${rawThinkChars} think chars, inThinkBlock=${inThinkBlock}, toolCalls=${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
+          }
+        }
+
+        // ── 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) {
+          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 });
+          }
+        }
+
         this.emit('tool_activity', {
           agentId,
           event: 'api_call_end',
@@ -501,7 +569,7 @@ export class OllamaAgent extends EventEmitter {
       });
 
       console.log(`\n✅ [Ollama] Agent ${agentId} completed in ${(duration / 1000).toFixed(2)}s\n`);
-      return { success: true, agentId, duration };
+      return { success: true, agentId, duration, result: { output: finalContent } };
 
     } catch (err) {
       this.activeAgents.delete(agentId);