@ducci/jarvis 1.0.8 → 1.0.10

package/src/server/agent.js

@@ -62,7 +62,9 @@ async function callModelWithFallback(client, config, messages, tools) {
  * Runs a single agent loop up to maxIterations.
  * Returns { iteration, response, logSummary, status, runToolCalls, checkpoint }.
  */
-async function runAgentLoop(client, config, session, tools, toolDefs, prepareMessages) {
+async function runAgentLoop(client, config, session, prepareMessages) {
+  let tools = loadTools();
+  let toolDefs = getToolDefinitions(tools);
   let iteration = 0;
   const runToolCalls = [];
   let done = false;
@@ -85,7 +87,20 @@ async function runAgentLoop(client, config, session, tools, toolDefs, prepareMes
         status: 'model_error',
         runToolCalls,
         checkpoint: null,
-        errorDetail: e.apiErrors ?? { message: e.message },
+        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 },
       };
     }
@@ -100,6 +115,7 @@ async function runAgentLoop(client, config, session, tools, toolDefs, prepareMes
         tool_calls: assistantMessage.tool_calls,
       });
 
+      let toolsModified = false;
       for (const toolCall of assistantMessage.tool_calls) {
         const toolName = toolCall.function.name;
         let toolArgs;
@@ -118,6 +134,10 @@ async function runAgentLoop(client, config, session, tools, toolDefs, prepareMes
           toolStatus = 'error';
         }
 
+        if (toolName === 'save_tool' && toolStatus === 'ok') {
+          toolsModified = true;
+        }
+
         const resultStr = typeof result === 'string' ? result : JSON.stringify(result);
         runToolCalls.push({ name: toolName, args: toolArgs, status: toolStatus, result: resultStr });
 
@@ -128,6 +148,12 @@ async function runAgentLoop(client, config, session, tools, toolDefs, prepareMes
         });
       }
 
+      // Reload tools if any were created/updated this iteration
+      if (toolsModified) {
+        tools = loadTools();
+        toolDefs = getToolDefinitions(tools);
+      }
+
       continue;
     }
 
@@ -168,7 +194,20 @@ async function runAgentLoop(client, config, session, tools, toolDefs, prepareMes
         status: 'model_error',
         runToolCalls,
         checkpoint: null,
-        errorDetail: e.apiErrors ?? { message: e.message },
+        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 },
       };
     }
@@ -225,9 +264,6 @@ export async function handleChat(config, requestSessionId, userMessage) {
   session.messages.push({ role: 'user', content: userMessage });
   session.metadata.handoffCount = 0;
 
-  const tools = loadTools();
-  const toolDefs = getToolDefinitions(tools);
-
   // Resolves {{user_info}} in system prompt at runtime (never persisted)
   function prepareMessages(messages) {
     return messages.map((msg, i) => {
@@ -244,63 +280,79 @@ 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, 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;
+      }
 
-      const logEntry = {
+      // Checkpoint reached — log this run
+      appendLog(sessionId, {
         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: run.runToolCalls,
-      response: run.response,
-      logSummary: run.logSummary,
-      status: 'checkpoint_reached',
-    });
+        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);

package/src/server/app.js

@@ -6,6 +6,7 @@ import { realpathSync } from 'fs';
 import { loadConfig, ensureDirectories } from './config.js';
 import { seedTools } from './tools.js';
 import { handleChat } from './agent.js';
+import { startTelegramChannel } from '../channels/telegram/index.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -74,6 +75,7 @@ function startServer() {
   const PORT = config.port;
   app.listen(PORT, () => {
     console.log(`Jarvis server listening on port ${PORT}`);
+    startTelegramChannel(config);
   });
 }
 

package/src/server/config.js

@@ -49,6 +49,10 @@ export function loadConfig() {
     maxIterations: settings.maxIterations || 10,
     maxHandoffs: settings.maxHandoffs || 5,
     port: settings.port || 18008,
+    telegram: {
+      token: process.env.TELEGRAM_BOT_TOKEN || null,
+      allowedUserIds: settings.channels?.telegram?.allowedUserIds || [],
+    },
   };
 }
 

package/src/server/tools.js

@@ -90,6 +90,53 @@ const SEED_TOOLS = {
     },
     code: `const filePath = path.join(process.env.HOME, '.jarvis/data/user-info.json'); const raw = await fs.promises.readFile(filePath, 'utf8').catch(() => '{"items":[]}'); const { items } = JSON.parse(raw); return { status: 'ok', items };`,
   },
+  save_tool: {
+    definition: {
+      type: 'function',
+      function: {
+        name: 'save_tool',
+        description: 'Create or update a custom tool and make it available immediately in this session. Use this to build reusable JS tools for tasks you repeat. The tool code runs in Node.js and has access to: args, fs, path, process, require.',
+        parameters: {
+          type: 'object',
+          properties: {
+            name: {
+              type: 'string',
+              description: 'Tool name in snake_case (e.g. "parse_json_file"). Must be unique.',
+            },
+            description: {
+              type: 'string',
+              description: 'What the tool does. Be specific — the LLM uses this to decide when to call it.',
+            },
+            parameters: {
+              type: 'object',
+              description: 'JSON Schema object for the tool parameters (with type, properties, required fields).',
+            },
+            code: {
+              type: 'string',
+              description: 'The body of an async function. Must end with a return statement — the returned value becomes the tool result. Available bindings: args (your tool parameters), fs (node:fs), path (node:path), process, require. Do NOT wrap in a function declaration. Example: const raw = await fs.promises.readFile(args.filePath, "utf8"); const data = JSON.parse(raw); return { count: data.length, first: data[0] };',
+            },
+          },
+          required: ['name', 'description', 'parameters', 'code'],
+        },
+      },
+    },
+    code: `const toolsFile = path.join(process.env.HOME, '.jarvis/data/tools/tools.json'); const raw = await fs.promises.readFile(toolsFile, 'utf8').catch(() => '{}'); const tools = JSON.parse(raw); tools[args.name] = { definition: { type: 'function', function: { name: args.name, description: args.description, parameters: args.parameters } }, code: args.code }; await fs.promises.writeFile(toolsFile, JSON.stringify(tools, null, 2), 'utf8'); return { status: 'ok', saved: args.name };`,
+  },
+  list_tools: {
+    definition: {
+      type: 'function',
+      function: {
+        name: 'list_tools',
+        description: 'List all available tools with their names and descriptions. Use this to see what tools exist before creating a new one.',
+        parameters: {
+          type: 'object',
+          properties: {},
+          required: [],
+        },
+      },
+    },
+    code: `const toolsFile = path.join(process.env.HOME, '.jarvis/data/tools/tools.json'); const raw = await fs.promises.readFile(toolsFile, 'utf8').catch(() => '{}'); const tools = JSON.parse(raw); const list = Object.entries(tools).map(([name, t]) => ({ name, description: t.definition.function.description })); return { status: 'ok', tools: list };`,
+  },
   get_recent_sessions: {
     definition: {
       type: 'function',