@ducci/jarvis 1.0.7 → 1.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ducci/jarvis",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "A fully automated agent system that lives on a server.",
   "main": "./src/index.js",
   "type": "module",
@@ -20,7 +20,7 @@
     "setup": "node ./src/scripts/onboarding.js",
     "dev": "nodemon ./src/server/app.js",
     "prepare": "cd ui && npm install && npm run build",
-    "publish": "node scripts/publish.js",
+    "release": "node scripts/publish.js",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "keywords": [

package/src/server/agent.js

@@ -4,6 +4,7 @@ import { loadSystemPrompt, resolveSystemPrompt } from './config.js';
 import { loadSession, saveSession, createSession } from './sessions.js';
 import { loadTools, getToolDefinitions, executeTool } from './tools.js';
 import { appendLog } from './logging.js';
+import chalk from 'chalk';
 
 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:
@@ -27,17 +28,33 @@ async function callModel(client, model, messages, tools) {
   return await client.chat.completions.create(params);
 }
 
+function extractApiError(err, model) {
+  return {
+    model,
+    httpStatus: err?.status ?? null,
+    message: err?.message ?? String(err),
+    body: err?.error ?? null,
+  };
+}
+
 async function callModelWithFallback(client, config, messages, tools) {
+  let primaryErr = null;
   try {
     return await callModel(client, config.selectedModel, messages, tools);
-  } catch (primaryErr) {
-    try {
-      return await callModel(client, config.fallbackModel, messages, tools);
-    } catch (fallbackErr) {
-      throw new Error(
-        `Both primary (${config.selectedModel}) and fallback (${config.fallbackModel}) models failed. Last error: ${fallbackErr.message}`
-      );
-    }
+  } catch (err) {
+    primaryErr = err;
+  }
+  try {
+    return await callModel(client, config.fallbackModel, messages, tools);
+  } catch (fallbackErr) {
+    const combined = new Error(
+      `Both primary (${config.selectedModel}) and fallback (${config.fallbackModel}) models failed. Last error: ${fallbackErr.message}`
+    );
+    combined.apiErrors = {
+      primary: extractApiError(primaryErr, config.selectedModel),
+      fallback: extractApiError(fallbackErr, config.fallbackModel),
+    };
+    throw combined;
   }
 }
 
@@ -57,8 +74,9 @@ async function runAgentLoop(client, config, session, tools, toolDefs, prepareMes
     iteration++;
 
     let modelResult;
+    const preparedMessages = prepareMessages(session.messages);
     try {
-      modelResult = await callModelWithFallback(client, config, prepareMessages(session.messages), toolDefs);
+      modelResult = await callModelWithFallback(client, config, preparedMessages, toolDefs);
     } catch (e) {
       return {
         iteration,
@@ -67,6 +85,21 @@ async function runAgentLoop(client, config, session, tools, toolDefs, prepareMes
         status: 'model_error',
         runToolCalls,
         checkpoint: null,
+        errorDetail: e.apiErrors ?? { message: e.message, stack: e.stack },
+        contextInfo: { messageCount: preparedMessages.length },
+      };
+    }
+
+    if (!modelResult.choices || modelResult.choices.length === 0) {
+      return {
+        iteration,
+        response: 'Model returned an empty response.',
+        logSummary: `Model error on iteration ${iteration}: Empty choices array.`,
+        status: 'model_error',
+        runToolCalls,
+        checkpoint: null,
+        errorDetail: { message: 'Empty choices array from LLM' },
+        contextInfo: { messageCount: preparedMessages.length },
       };
     }
 
@@ -123,6 +156,7 @@ async function runAgentLoop(client, config, session, tools, toolDefs, prepareMes
       response = content;
       logSummary = 'Model returned non-JSON final response.';
       status = 'format_error';
+      return { iteration, response, logSummary, status, runToolCalls, checkpoint: null, rawResponse: content };
     }
 
     done = true;
@@ -147,6 +181,21 @@ async function runAgentLoop(client, config, session, tools, toolDefs, prepareMes
         status: 'model_error',
         runToolCalls,
         checkpoint: null,
+        errorDetail: e.apiErrors ?? { message: e.message, stack: e.stack },
+        contextInfo: { messageCount: wrapUpMessages.length },
+      };
+    }
+
+    if (!wrapUpResult.choices || wrapUpResult.choices.length === 0) {
+      return {
+        iteration,
+        response: 'Wrap-up call returned an empty response.',
+        logSummary: 'Iteration limit reached. Wrap-up returned empty choices.',
+        status: 'model_error',
+        runToolCalls,
+        checkpoint: null,
+        errorDetail: { message: 'Empty choices array in wrap-up' },
+        contextInfo: { messageCount: wrapUpMessages.length },
       };
     }
 
@@ -221,63 +270,85 @@ export async function handleChat(config, requestSessionId, userMessage) {
   let finalStatus = 'ok';
 
   // Handoff loop
-  while (true) {
-    const run = await runAgentLoop(client, config, session, tools, toolDefs, prepareMessages);
-    allToolCalls.push(...run.runToolCalls);
-
-    if (run.status !== 'checkpoint_reached') {
-      finalResponse = run.response;
-      finalLogSummary = run.logSummary;
-      finalStatus = run.status;
+  try {
+    while (true) {
+      const run = await runAgentLoop(client, config, session, tools, toolDefs, prepareMessages);
+      allToolCalls.push(...run.runToolCalls);
+
+      if (run.status !== 'checkpoint_reached') {
+        finalResponse = run.response;
+        finalLogSummary = run.logSummary;
+        finalStatus = run.status;
+
+        const logEntry = {
+          iteration: run.iteration,
+          model: config.selectedModel,
+          userInput: userMessage,
+          toolCalls: allToolCalls,
+          response: finalResponse,
+          logSummary: finalLogSummary,
+          status: finalStatus,
+        };
+        if (run.errorDetail) logEntry.errorDetail = run.errorDetail;
+        if (run.contextInfo) logEntry.contextInfo = run.contextInfo;
+        if (run.rawResponse) logEntry.rawResponse = run.rawResponse;
+        appendLog(sessionId, logEntry);
+        break;
+      }
 
+      // Checkpoint reached — log this run
       appendLog(sessionId, {
         iteration: run.iteration,
         model: config.selectedModel,
         userInput: userMessage,
-        toolCalls: allToolCalls,
-        response: finalResponse,
-        logSummary: finalLogSummary,
-        status: finalStatus,
+        toolCalls: run.runToolCalls,
+        response: run.response,
+        logSummary: run.logSummary,
+        status: 'checkpoint_reached',
       });
-      break;
-    }
-
-    // Checkpoint reached — log this run
-    appendLog(sessionId, {
-      iteration: run.iteration,
-      model: config.selectedModel,
-      userInput: userMessage,
-      toolCalls: run.runToolCalls,
-      response: run.response,
-      logSummary: run.logSummary,
-      status: 'checkpoint_reached',
-    });
 
-    // Check handoff limit
-    session.metadata.handoffCount++;
-    if (session.metadata.handoffCount > config.maxHandoffs) {
-      finalResponse = run.response;
-      finalLogSummary = run.logSummary;
-      finalStatus = 'intervention_required';
+      // Check handoff limit
+      session.metadata.handoffCount++;
+      if (session.metadata.handoffCount > config.maxHandoffs) {
+        finalResponse = run.response;
+        finalLogSummary = run.logSummary;
+        finalStatus = 'intervention_required';
+
+        appendLog(sessionId, {
+          iteration: 0,
+          model: config.selectedModel,
+          userInput: userMessage,
+          toolCalls: [],
+          response: finalResponse,
+          logSummary: 'Max handoffs exceeded. Human intervention required.',
+          status: 'intervention_required',
+        });
+        break;
+      }
 
-      appendLog(sessionId, {
-        iteration: 0,
-        model: config.selectedModel,
-        userInput: userMessage,
-        toolCalls: [],
-        response: finalResponse,
-        logSummary: 'Max handoffs exceeded. Human intervention required.',
-        status: 'intervention_required',
-      });
-      break;
+      // Resume with checkpoint.remaining as new prompt
+      session.messages.push({ role: 'user', content: run.checkpoint.remaining });
     }
-
-    // Resume with checkpoint.remaining as new prompt
-    session.messages.push({ role: 'user', content: run.checkpoint.remaining });
+  } catch (e) {
+    const errorLog = {
+      iteration: 0,
+      model: config.selectedModel,
+      userInput: userMessage,
+      toolCalls: allToolCalls,
+      response: `An unexpected server error occurred: ${e.message}`,
+      logSummary: `Critical error: ${e.message}`,
+      status: 'error',
+      errorDetail: { message: e.message, stack: e.stack },
+    };
+    appendLog(sessionId, errorLog);
+    // Re-throw to let app.js handle the HTTP response
+    throw e;
   }
 
   saveSession(sessionId, session);
 
+  console.log(`${chalk.magenta('<<<')} ${chalk.bold('Final Response')} [SID: ${chalk.dim(sessionId.slice(0, 8))}] ${chalk.italic(finalLogSummary)}`);
+
   return {
     sessionId,
     response: finalResponse,

package/src/server/app.js

@@ -1,5 +1,6 @@
 import express from 'express';
 import path from 'path';
+import chalk from 'chalk';
 import { fileURLToPath } from 'url';
 import { realpathSync } from 'fs';
 import { loadConfig, ensureDirectories } from './config.js';
@@ -12,6 +13,15 @@ const __dirname = path.dirname(__filename);
 const app = express();
 app.use(express.json());
 
+// Request logger
+app.use((req, res, next) => {
+  if (req.path === '/api/chat' && req.method === 'POST') {
+    const sid = req.body.sessionId || 'new';
+    console.log(`\n${chalk.magenta('>>>')} ${chalk.bold('Incoming Chat')} [SID: ${chalk.dim(sid.slice(0, 8))}]`);
+  }
+  next();
+});
+
 // Serve the built UI as static files
 const uiDist = path.join(__dirname, '..', '..', 'ui', 'dist');
 app.use(express.static(uiDist));

package/src/server/logging.js

@@ -1,9 +1,20 @@
 import fs from 'fs';
 import path from 'path';
+import chalk from 'chalk';
 import { PATHS } from './config.js';
 
 export function appendLog(sessionId, entry) {
   const logFile = path.join(PATHS.logsDir, `session-${sessionId}.jsonl`);
   const line = JSON.stringify({ ts: new Date().toISOString(), sessionId, ...entry }) + '\n';
   fs.appendFileSync(logFile, line, 'utf8');
+
+  // Console output for better visibility
+  const statusColor = entry.status === 'ok' ? chalk.green : chalk.red;
+  console.log(
+    `[${chalk.dim(new Date().toLocaleTimeString())}] ` +
+    `${chalk.blue('Session')}: ${chalk.dim(sessionId.slice(0, 8))} | ` +
+    `${chalk.yellow('Iter')}: ${entry.iteration} | ` +
+    `${chalk.cyan('Status')}: ${statusColor(entry.status)} | ` +
+    `${entry.logSummary || '(no summary)'}`
+  );
 }