@ducci/jarvis 1.0.9 → 1.0.11

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:
 
@@ -62,7 +64,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;
@@ -110,9 +114,16 @@ async function runAgentLoop(client, config, session, tools, toolDefs, prepareMes
       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;
       for (const toolCall of assistantMessage.tool_calls) {
         const toolName = toolCall.function.name;
         let toolArgs;
@@ -131,6 +142,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 });
 
@@ -141,24 +156,55 @@ 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;
     }
 
     // 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;
   }
@@ -251,9 +297,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) => {
@@ -272,7 +315,7 @@ export async function handleChat(config, requestSessionId, userMessage) {
   // Handoff loop
   try {
     while (true) {
-      const run = await runAgentLoop(client, config, session, tools, toolDefs, prepareMessages);
+      const run = await runAgentLoop(client, config, session, prepareMessages);
       allToolCalls.push(...run.runToolCalls);
 
       if (run.status !== 'checkpoint_reached') {
@@ -293,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;
       }
 

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',