@ducci/jarvis 1.0.10 → 1.0.11

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.11",
   "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,8 @@ 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 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:
 
@@ -112,7 +114,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;
@@ -158,20 +166,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;
   }
@@ -303,6 +336,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;
       }