@ducci/jarvis 1.0.10 → 1.0.12

package/docs/agent.md

@@ -198,7 +198,7 @@ Seed tool included for sanity checks:
 Jarvis uses the provider tool-calling API:
 
 1. The model returns an assistant message containing a `tool_calls` array.
-2. Jarvis appends that assistant message to the conversation history as-is.
+2. Jarvis normalizes each tool call before appending to the conversation history: if `function.arguments` is missing or empty, it is set to `"{}"`. Some models (especially smaller/free ones) omit `arguments` for no-arg tools. Storing a malformed tool call would cause the next API request to fail with a 400 validation error.
 3. Jarvis executes those tools in order, serially.
 4. Each tool result is appended to the conversation as a `role: "tool"` message with a matching `tool_call_id`.
 5. Jarvis calls the model again with the updated conversation.
@@ -447,7 +447,13 @@ Tool inputs/outputs:
 
 - Model call failures: try the selected model once, then one fallback model attempt. If both fail, end the run with a `500` error and a clear message.
 - Tool failures: pass the error result back to the model and continue the loop. Best case would be that the next model response include another tool call to fix the previous tool call. All tool errors (especially `exec` failures) must be reported in the `logSummary` with enough detail for a human to understand the cause.
-- Malformed JSON on final response: log the failure and stop the run with a formatted error message.
+- Malformed JSON on final response: attempt two recovery steps before giving up:
+  1. **Fallback model retry** — call the fallback model with the same conversation messages (the bad response is not saved to the session yet). If this produces valid JSON, use it and continue normally.
+  2. **Nudge retry** — if the fallback model also returns non-JSON, append a temporary nudge message to the conversation (not saved to the session) and call `callModelWithFallback` once more:
+     ```
+     Your previous response was not valid JSON. Respond only with the required JSON object: {"response": "...", "logSummary": "..."}
+     ```
+  3. **Give up** — if all three attempts fail, return `format_error` without pushing any assistant content to the session. The nudge message is never persisted regardless of outcome.
 
 **Error Payload Structure**:
 
@@ -462,6 +468,14 @@ Tool inputs/outputs:
 - Use `500 Internal Server Error` for API failures, tool runtime errors, or model communication issues.
 - Always append a log entry on failure so the outcome is visible in the session log.
 
+**Synthetic error note on failure**: when a run ends with `model_error` or `format_error`, a synthetic assistant message is appended to the session before saving:
+
+```
+[System: Previous run failed (model_error): <logSummary>. Error detail: <errorDetail JSON>]
+```
+
+The full `errorDetail` (provider error body, HTTP status, etc.) is included so the model has enough information to understand and potentially recover from the failure without needing to call `read_session_log`. Without this, the session would contain a dangling user message with no reply, and the model would have no way to understand or recover from the failure.
+
 Model configuration:
 
 - Selected model ID is stored in the same config file created during setup.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ducci/jarvis",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "description": "A fully automated agent system that lives on a server.",
   "main": "./src/index.js",
   "type": "module",

package/src/server/agent.js

@@ -6,6 +6,9 @@ import { loadTools, getToolDefinitions, executeTool } from './tools.js';
 import { appendLog } from './logging.js';
 import chalk from 'chalk';
 
+const FORMAT_NUDGE = 'Your previous response was not valid JSON. Respond only with the required JSON object: {"response": "...", "logSummary": "..."}';
+const LOOP_DETECTION_THRESHOLD = 3;
+
 const WRAP_UP_NOTE = `[System: You have reached the iteration limit. This is your final response for this run.
 Respond with your normal JSON, but add a checkpoint field:
 
@@ -67,6 +70,7 @@ async function runAgentLoop(client, config, session, prepareMessages) {
   let toolDefs = getToolDefinitions(tools);
   let iteration = 0;
   const runToolCalls = [];
+  const loopTracker = new Map();
   let done = false;
   let response = '';
   let logSummary = '';
@@ -112,7 +116,13 @@ async function runAgentLoop(client, config, session, prepareMessages) {
       session.messages.push({
         role: 'assistant',
         content: assistantMessage.content || null,
-        tool_calls: assistantMessage.tool_calls,
+        tool_calls: assistantMessage.tool_calls.map(tc => ({
+          ...tc,
+          function: {
+            ...tc.function,
+            arguments: tc.function.arguments || '{}',
+          },
+        })),
       });
 
       let toolsModified = false;
@@ -146,6 +156,17 @@ async function runAgentLoop(client, config, session, prepareMessages) {
           tool_call_id: toolCall.id,
           content: resultStr,
         });
+
+        const callKey = `${toolName}|${JSON.stringify(toolArgs)}|${resultStr}`;
+        loopTracker.set(callKey, (loopTracker.get(callKey) || 0) + 1);
+      }
+
+      const loopDetected = [...loopTracker.values()].some(count => count >= LOOP_DETECTION_THRESHOLD);
+      if (loopDetected) {
+        session.messages.push({
+          role: 'user',
+          content: '[System: Loop detected. You are repeatedly calling the same tools with identical arguments and getting identical results. Stop calling tools and provide your final answer now based on what you already know.]',
+        });
       }
 
       // Reload tools if any were created/updated this iteration
@@ -158,20 +179,45 @@ async function runAgentLoop(client, config, session, prepareMessages) {
     }
 
     // No tool calls — final response
-    const content = assistantMessage.content || '';
-    session.messages.push({ role: 'assistant', content });
+    // Delay pushing to session until we have a valid response (recovery may replace it)
+    let content = assistantMessage.content || '';
+    let parsed = null;
 
     try {
-      const parsed = JSON.parse(content);
-      response = parsed.response || content;
-      logSummary = parsed.logSummary || '';
+      parsed = JSON.parse(content);
     } catch {
+      // Step 1: retry with fallback model
+      try {
+        const fallbackResult = await callModel(client, config.fallbackModel, preparedMessages, toolDefs);
+        const fallbackContent = fallbackResult.choices[0]?.message?.content || '';
+        parsed = JSON.parse(fallbackContent);
+        content = fallbackContent;
+      } catch {
+        // Step 2: nudge retry via both models
+        try {
+          const nudgeMessages = [...preparedMessages, { role: 'user', content: FORMAT_NUDGE }];
+          const nudgeResult = await callModelWithFallback(client, config, nudgeMessages, toolDefs);
+          const nudgeContent = nudgeResult.choices[0]?.message?.content || '';
+          parsed = JSON.parse(nudgeContent);
+          content = nudgeContent;
+        } catch {
+          // Give up
+        }
+      }
+    }
+
+    if (!parsed) {
+      // Don't push bad content — handleChat will inject a synthetic error note
       response = content;
-      logSummary = 'Model returned non-JSON final response.';
+      logSummary = 'Model returned non-JSON final response after recovery attempts.';
       status = 'format_error';
       return { iteration, response, logSummary, status, runToolCalls, checkpoint: null, rawResponse: content };
     }
 
+    session.messages.push({ role: 'assistant', content });
+    response = parsed.response || content;
+    logSummary = parsed.logSummary || '';
+
     done = true;
     break;
   }
@@ -212,31 +258,47 @@ async function runAgentLoop(client, config, session, prepareMessages) {
       };
     }
 
-    const wrapUpContent = wrapUpResult.choices[0].message.content || '';
-    // Store the wrap-up response (but NOT the temporary system note)
-    session.messages.push({ role: 'assistant', content: wrapUpContent });
+    let wrapUpContent = wrapUpResult.choices[0].message.content || '';
+    let parsedWrapUp = null;
 
+    // Try JSON parse; if it fails, nudge retry (Layer 2)
     try {
-      const parsed = JSON.parse(wrapUpContent);
-      response = parsed.response || '';
-      logSummary = parsed.logSummary || '';
+      parsedWrapUp = JSON.parse(wrapUpContent);
+    } catch {
+      try {
+        const nudgeMessages = [...wrapUpMessages, { role: 'user', content: FORMAT_NUDGE }];
+        const nudgeResult = await callModelWithFallback(client, config, nudgeMessages, []);
+        const nudgeContent = nudgeResult.choices[0]?.message?.content || '';
+        parsedWrapUp = JSON.parse(nudgeContent);
+        wrapUpContent = nudgeContent;
+      } catch {
+        // Layer 3: use raw text as best-effort response below
+      }
+    }
+
+    // Store the wrap-up response (but NOT the temporary system note)
+    session.messages.push({ role: 'assistant', content: wrapUpContent });
 
-      if (parsed.checkpoint) {
+    if (parsedWrapUp) {
+      response = parsedWrapUp.response || '';
+      logSummary = parsedWrapUp.logSummary || '';
+      if (parsedWrapUp.checkpoint) {
         return {
           iteration,
           response,
           logSummary,
           status: 'checkpoint_reached',
           runToolCalls,
-          checkpoint: parsed.checkpoint,
+          checkpoint: parsedWrapUp.checkpoint,
         };
       }
-    } catch {
+      status = 'ok';
+    } else {
+      // Layer 3: use raw text — user gets a real response instead of an error
       response = wrapUpContent;
-      logSummary = 'Wrap-up response was not valid JSON.';
+      logSummary = 'Wrap-up response was not valid JSON after retry.';
+      status = 'ok';
     }
-
-    status = 'checkpoint_reached';
   }
 
   return { iteration, response, logSummary, status, runToolCalls, checkpoint: null };
@@ -303,6 +365,16 @@ export async function handleChat(config, requestSessionId, userMessage) {
         if (run.contextInfo) logEntry.contextInfo = run.contextInfo;
         if (run.rawResponse) logEntry.rawResponse = run.rawResponse;
         appendLog(sessionId, logEntry);
+
+        // Inject synthetic error note so the model has context on the next user turn
+        if (finalStatus === 'model_error' || finalStatus === 'format_error') {
+          const errorDetail = run.errorDetail ? ` Error detail: ${JSON.stringify(run.errorDetail)}` : '';
+          session.messages.push({
+            role: 'assistant',
+            content: `[System: Previous run failed (${finalStatus}): ${finalLogSummary}.${errorDetail}]`,
+          });
+        }
+
         break;
       }