@ducci/jarvis 1.0.9 → 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;
@@ -113,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;
@@ -131,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 });
 
@@ -141,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;
     }
 
@@ -251,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) => {
@@ -272,7 +282,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') {

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