@hamp10/agentforge 0.2.12 → 0.2.14

package/package.json

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

package/src/OllamaAgent.js

@@ -110,26 +110,65 @@ 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.
+ * 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;
 }
@@ -254,7 +293,7 @@ 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 {
@@ -366,7 +405,12 @@ export class OllamaAgent extends EventEmitter {
               thinkBuffer = inThinkBlock ? thinkBuffer.slice(thinkBuffer.lastIndexOf('<think>')) : '';
 
               streamContent += out;
-              // Don't emit per-token — we check for JSON tool calls after the full turn
+              // Stream text tokens live — but only if output clearly isn't JSON tool calls.
+              // If the accumulated content starts with '{', it may be a tool call — buffer silently.
+              // Otherwise emit immediately so the user sees live output.
+              if (out && !streamContent.trimStart().startsWith('{')) {
+                this.emit('agent_output', { agentId, output: out, isChunk: true });
+              }
             }
           }
         }
@@ -386,10 +430,10 @@ export class OllamaAgent extends EventEmitter {
           }
         }
 
-        // ── 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.
+        // ── Detect text-based tool calls or accumulate text content ──────────
+        // qwen3-vl:8b outputs tool calls as JSON in content (not tool_calls field).
+        // If detected, convert to streamToolCalls so they actually execute.
+        // If not tool calls, content was already streamed live token-by-token above.
         if (Object.keys(streamToolCalls).length === 0 && streamContent) {
           const textCalls = _parseTextToolCalls(streamContent);
           if (textCalls) {
@@ -401,11 +445,10 @@ export class OllamaAgent extends EventEmitter {
                 function: { name: tc.name, arguments: JSON.stringify(tc.arguments) }
               };
             });
-            streamContent = ''; // Don't display raw JSON to user
+            streamContent = ''; // Suppress raw JSON from output
           } else {
-            // Regular text response — emit to dashboard
+            // Regular text — already emitted live above, just accumulate
             allOutput += streamContent;
-            if (streamContent.trim()) this.emit('agent_output', { agentId, output: streamContent });
           }
         }
 
@@ -781,7 +824,7 @@ export class OllamaAgent extends EventEmitter {
       if (existsSync(fp)) {
         const data = JSON.parse(readFileSync(fp, 'utf-8'));
         // Keep last 20 messages to stay within context
-        return data.slice(-20);
+        return data.slice(-12);
       }
     } catch {}
     return [];
@@ -790,7 +833,7 @@ export class OllamaAgent extends EventEmitter {
   _saveHistory(agentId, workDir, sessionId, messages) {
     try {
       const fp = this._historyPath(workDir, sessionId);
-      writeFileSync(fp, JSON.stringify(messages.slice(-40), null, 2));
+      writeFileSync(fp, JSON.stringify(messages.slice(-20), null, 2));
     } catch {}
   }
 }

package/src/worker.js

@@ -1206,7 +1206,9 @@ export class AgentForgeWorker extends EventEmitter {
         // Only inject history when gateway is unavailable (subprocess fallback).
         // Hampagent manages its own session history natively — never inject DB history for it
         const gatewayActive = !!(this.cli.gatewayPort && this.cli.gatewayToken);
-        const sessionExists = useHampagent || gatewayActive;
+        // OllamaAgent manages its own disk-based session history natively —
+        // injecting DB history as text would double the context and overflow the model.
+        const sessionExists = useHampagent || gatewayActive || isLocalModelRunner;
 
         if (!sessionExists) {
           // Session is gone — inject DB history as context prefix so the agent remembers