protoagent 0.1.10 → 0.1.11

package/dist/sub-agent.js

@@ -28,7 +28,7 @@ export const subAgentTool = {
                 },
                 max_iterations: {
                     type: 'number',
-                    description: 'Maximum tool-call iterations for the sub-agent. Defaults to 30.',
+                    description: 'Maximum tool-call iterations for the sub-agent. Defaults to 500.',
                 },
             },
             required: ['task'],
@@ -39,7 +39,7 @@ export const subAgentTool = {
  * Run a sub-agent with its own isolated conversation.
  * Returns the sub-agent's final text response.
  */
-export async function runSubAgent(client, model, task, maxIterations = 30, requestDefaults = {}, onProgress, abortSignal) {
+export async function runSubAgent(client, model, task, maxIterations = 500, requestDefaults = {}, onProgress, abortSignal, pricing) {
     const op = logger.startOperation('sub-agent');
     const subAgentSessionId = `sub-agent-${crypto.randomUUID()}`;
     const systemPrompt = await generateSystemPrompt();
@@ -54,35 +54,142 @@ Do NOT ask the user questions — work autonomously with the tools available.`;
         { role: 'system', content: subSystemPrompt },
         { role: 'user', content: task },
     ];
+    // Track cumulative usage across all API calls in the sub-agent
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    let totalCost = 0;
     try {
         for (let i = 0; i < maxIterations; i++) {
             // Check abort at the top of each iteration
             if (abortSignal?.aborted) {
-                return '(sub-agent aborted)';
+                return { response: '(sub-agent aborted)', usage: { inputTokens: totalInputTokens, outputTokens: totalOutputTokens, cost: totalCost } };
             }
-            const response = await client.chat.completions.create({
-                ...requestDefaults,
-                model,
-                messages,
-                tools: getAllTools(),
-                tool_choice: 'auto',
-            }, { signal: abortSignal });
-            const message = response.choices[0]?.message;
+            let assistantMessage;
+            let hasToolCalls = false;
+            try {
+                const stream = await client.chat.completions.create({
+                    ...requestDefaults,
+                    model,
+                    messages,
+                    tools: getAllTools(),
+                    tool_choice: 'auto',
+                    stream: true,
+                    stream_options: { include_usage: true },
+                }, { signal: abortSignal });
+                // Accumulate the streamed response
+                assistantMessage = {
+                    role: 'assistant',
+                    content: '',
+                    tool_calls: [],
+                };
+                let streamedContent = '';
+                hasToolCalls = false;
+                let actualUsage;
+                for await (const chunk of stream) {
+                    const delta = chunk.choices[0]?.delta;
+                    if (chunk.usage) {
+                        actualUsage = chunk.usage;
+                    }
+                    // Stream text content
+                    if (delta?.content) {
+                        streamedContent += delta.content;
+                        assistantMessage.content = streamedContent;
+                    }
+                    // Accumulate tool calls across stream chunks
+                    if (delta?.tool_calls) {
+                        hasToolCalls = true;
+                        for (const tc of delta.tool_calls) {
+                            const idx = tc.index || 0;
+                            if (!assistantMessage.tool_calls[idx]) {
+                                assistantMessage.tool_calls[idx] = {
+                                    id: '',
+                                    type: 'function',
+                                    function: { name: '', arguments: '' },
+                                };
+                            }
+                            if (tc.id)
+                                assistantMessage.tool_calls[idx].id = tc.id;
+                            if (tc.function?.name) {
+                                assistantMessage.tool_calls[idx].function.name += tc.function.name;
+                            }
+                            if (tc.function?.arguments) {
+                                assistantMessage.tool_calls[idx].function.arguments += tc.function.arguments;
+                            }
+                        }
+                    }
+                }
+                // Accumulate usage for this iteration
+                const iterationInputTokens = actualUsage?.prompt_tokens || 0;
+                const iterationOutputTokens = actualUsage?.completion_tokens || 0;
+                totalInputTokens += iterationInputTokens;
+                totalOutputTokens += iterationOutputTokens;
+                // Calculate cost if pricing is available
+                if (pricing && (iterationInputTokens > 0 || iterationOutputTokens > 0)) {
+                    const cachedTokens = actualUsage?.prompt_tokens_details?.cached_tokens;
+                    if (cachedTokens && cachedTokens > 0 && pricing.cachedPerToken != null) {
+                        const uncachedTokens = iterationInputTokens - cachedTokens;
+                        totalCost += uncachedTokens * pricing.inputPerToken + cachedTokens * pricing.cachedPerToken + iterationOutputTokens * pricing.outputPerToken;
+                    }
+                    else {
+                        totalCost += iterationInputTokens * pricing.inputPerToken + iterationOutputTokens * pricing.outputPerToken;
+                    }
+                }
+            }
+            catch (err) {
+                // If aborted during streaming, return gracefully
+                if (abortSignal?.aborted || (err instanceof Error && (err.name === 'AbortError' || err.message === 'Operation aborted'))) {
+                    logger.debug('Sub-agent aborted during streaming');
+                    return { response: '(sub-agent aborted)', usage: { inputTokens: totalInputTokens, outputTokens: totalOutputTokens, cost: totalCost } };
+                }
+                throw err;
+            }
+            const message = assistantMessage;
             if (!message)
                 break;
             // Check for tool calls
-            if (message.tool_calls && message.tool_calls.length > 0) {
-                messages.push(message);
-                for (const toolCall of message.tool_calls) {
+            if (hasToolCalls && assistantMessage.tool_calls.length > 0) {
+                // Clean up empty tool_calls entries (from sparse array)
+                assistantMessage.tool_calls = assistantMessage.tool_calls.filter(Boolean);
+                // Filter out tool calls with malformed JSON arguments (can happen if stream aborted mid-tool-call)
+                assistantMessage.tool_calls = assistantMessage.tool_calls.filter((tc) => {
+                    const args = tc.function?.arguments;
+                    if (!args)
+                        return true; // No args is valid
+                    try {
+                        JSON.parse(args);
+                        return true;
+                    }
+                    catch {
+                        logger.warn('Filtering out sub-agent tool call with malformed JSON', {
+                            tool: tc.function?.name,
+                            argsPreview: args.slice(0, 100),
+                        });
+                        return false;
+                    }
+                });
+                // Only add message if we have valid tool calls
+                if (assistantMessage.tool_calls.length === 0) {
+                    hasToolCalls = false;
+                }
+                else {
+                    messages.push(message);
+                }
+                for (const toolCall of assistantMessage.tool_calls) {
                     // Check abort between tool calls
                     if (abortSignal?.aborted) {
-                        return '(sub-agent aborted)';
+                        return { response: '(sub-agent aborted)', usage: { inputTokens: totalInputTokens, outputTokens: totalOutputTokens, cost: totalCost } };
                     }
                     const { name, arguments: argsStr } = toolCall.function;
-                    logger.debug(`Sub-agent tool call: ${name}`);
-                    onProgress?.({ tool: name, status: 'running', iteration: i });
+                    let args;
+                    try {
+                        args = JSON.parse(argsStr);
+                    }
+                    catch {
+                        args = {};
+                    }
+                    logger.debug(`Sub-agent tool call: ${name}`, { args });
+                    onProgress?.({ tool: name, status: 'running', iteration: i, args });
                     try {
-                        const args = JSON.parse(argsStr);
                         const result = await handleToolCall(name, args, { sessionId: subAgentSessionId, abortSignal });
                         messages.push({
                             role: 'tool',
@@ -104,9 +211,20 @@ Do NOT ask the user questions — work autonomously with the tools available.`;
                 continue;
             }
             // Plain text response — we're done
-            return message.content || '(sub-agent completed with no response)';
+            if (message.content) {
+                messages.push({
+                    role: 'assistant',
+                    content: message.content,
+                });
+                return { response: message.content, usage: { inputTokens: totalInputTokens, outputTokens: totalOutputTokens, cost: totalCost } };
+            }
+            // The model produced an empty text response (e.g. it only called tools
+            // and issued no final summary).  Log it and return a sentinel so the
+            // parent agent knows the sub-agent finished but had nothing to say.
+            logger.debug('Sub-agent returned empty content', { iteration: i });
+            return { response: '(sub-agent completed with no response)', usage: { inputTokens: totalInputTokens, outputTokens: totalOutputTokens, cost: totalCost } };
         }
-        return '(sub-agent reached iteration limit)';
+        return { response: '(sub-agent reached iteration limit)', usage: { inputTokens: totalInputTokens, outputTokens: totalOutputTokens, cost: totalCost } };
     }
     finally {
         op.end();

package/dist/system-prompt.js

@@ -6,12 +6,45 @@
  *  - Working directory and project structure
  *  - Tool descriptions (auto-generated from tool schemas)
  *  - Skills catalog (loaded progressively from skill directories)
+ *  - AGENTS.md content (custom instructions for the agent)
  *  - Guidelines for file operations, TODO tracking, etc.
  */
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { getAllTools } from './tools/index.js';
 import { buildSkillsCatalogSection, initializeSkillsSupport } from './skills.js';
+import { getActiveRuntimeConfigPath } from './runtime-config.js';
+/**
+ * Load AGENTS.md content from cwd and parent directories.
+ *
+ * AGENTS.md (https://agents.md/) is a simple, open format for guiding coding agents.
+ * It's like a README for agents — a dedicated place to give AI coding tools the
+ * context they need to work on a project.
+ *
+ * The lookup is hierarchical:
+ *  - Checks cwd, then parent directories up to the filesystem root
+ *  - First AGENTS.md found wins
+ *  - Returns null if no AGENTS.md is found
+ */
+async function loadAgentsMd() {
+    let currentDir = path.resolve('.');
+    while (true) {
+        const agentsPath = path.join(currentDir, 'AGENTS.md');
+        try {
+            await fs.access(agentsPath);
+            const content = await fs.readFile(agentsPath, 'utf-8');
+            return { content, path: agentsPath };
+        }
+        catch {
+            // File doesn't exist here — check parent
+        }
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir)
+            break; // Reached filesystem root
+        currentDir = parentDir;
+    }
+    return null;
+}
 /** Build a filtered directory tree (depth 3, excludes noise). */
 async function buildDirectoryTree(dirPath = '.', depth = 0, maxDepth = 3) {
     if (depth > maxDepth)
@@ -66,6 +99,11 @@ export async function generateSystemPrompt() {
     const skills = await initializeSkillsSupport();
     const toolDescriptions = generateToolDescriptions();
     const skillsSection = buildSkillsCatalogSection(skills);
+    const configPath = getActiveRuntimeConfigPath();
+    const agentsMd = await loadAgentsMd();
+    const agentsMdSection = agentsMd
+        ? `\nAGENTS.md INSTRUCTIONS\n\nThe following instructions are from the AGENTS.md file at: ${agentsMd.path}\n\n${agentsMd.content}\n`
+        : '';
     return `You are ProtoAgent, a coding assistant with file system and shell command capabilities.
 Your job is to help the user complete coding tasks in their project. You must be absolutely careful and diligent in your work, and follow all guidelines to the letter. Always prefer thoroughness and correctness over speed. Never cut corners.
 
@@ -73,9 +111,16 @@ PROJECT CONTEXT
 
 Working Directory: ${cwd}
 Project Name: ${projectName}
+Configuration Path: ${configPath || 'none (using defaults)'}
 
 PROJECT STRUCTURE:
 ${tree}
+${agentsMdSection}
+PROTOAGENT DOCUMENTATION
+
+ProtoAgent is a build-your-own coding agent — a lean, readable implementation that gives you the blueprint to understand and build your own AI coding assistant.
+
+Configuration guide: https://protoagent.dev/guide/configuration
 
 AVAILABLE TOOLS
 

package/dist/tools/bash.js

@@ -27,7 +27,7 @@ export const bashTool = {
         },
     },
 };
-// Hard-blocked commands — these CANNOT be run, even with --dangerously-accept-all
+// Hard-blocked commands — these CANNOT be run, even with --dangerously-skip-permissions
 const DANGEROUS_PATTERNS = [
     'rm -rf /',
     'sudo',

package/dist/tools/index.js

@@ -16,7 +16,7 @@ import { searchFilesTool, searchFiles } from './search-files.js';
 import { bashTool, runBash } from './bash.js';
 import { todoReadTool, todoWriteTool, readTodos, writeTodos } from './todo.js';
 import { webfetchTool, webfetch } from './webfetch.js';
-export { setDangerouslyAcceptAll, setApprovalHandler, clearApprovalHandler } from '../utils/approval.js';
+export { setDangerouslySkipPermissions, setApprovalHandler, clearApprovalHandler } from '../utils/approval.js';
 // All tool definitions — passed to the LLM
 export const tools = [
     readFileTool,

package/dist/utils/approval.js

@@ -8,21 +8,21 @@
  * Approval can be granted:
  *  - Per-operation (one-time)
  *  - Per-operation-type for the session (e.g., "approve all writes")
- *  - Globally via --dangerously-accept-all
+ *  - Globally via --dangerously-skip-permissions
  *
  * In the Ink UI, approvals are handled by emitting an event and waiting
  * for the UI to resolve it (instead of blocking on stdin with inquirer).
  */
 // Global state
-let dangerouslyAcceptAll = false;
+let dangerouslySkipPermissions = false;
 const sessionApprovals = new Set(); // stores approval keys scoped by session
 // Callback that the Ink UI provides to handle interactive approval
 let approvalHandler = null;
-export function setDangerouslyAcceptAll(value) {
-    dangerouslyAcceptAll = value;
+export function setDangerouslySkipPermissions(value) {
+    dangerouslySkipPermissions = value;
 }
-export function isDangerouslyAcceptAll() {
-    return dangerouslyAcceptAll;
+export function isDangerouslySkipPermissions() {
+    return dangerouslySkipPermissions;
 }
 export function setApprovalHandler(handler) {
     approvalHandler = handler;
@@ -42,13 +42,13 @@ function getApprovalScopeKey(req) {
  * Request approval for an operation. Returns true if approved.
  *
  * Check order:
- *  1. --dangerously-accept-all → auto-approve
+ *  1. --dangerously-skip-permissions → auto-approve
  *  2. Session approval for this type → auto-approve
  *  3. Interactive prompt via the UI handler
  *  4. No handler registered → reject (fail closed)
  */
 export async function requestApproval(req) {
-    if (dangerouslyAcceptAll)
+    if (dangerouslySkipPermissions)
         return true;
     const sessionKey = getApprovalScopeKey(req);
     if (sessionApprovals.has(sessionKey))

package/dist/utils/cost-tracker.js

@@ -26,7 +26,13 @@ export function estimateConversationTokens(messages) {
     return messages.reduce((sum, m) => sum + estimateMessageTokens(m), 0) + 10;
 }
 /** Calculate dollar cost for a given number of tokens. */
-export function calculateCost(inputTokens, outputTokens, pricing) {
+export function calculateCost(inputTokens, outputTokens, pricing, cachedTokens) {
+    if (cachedTokens && cachedTokens > 0 && pricing.cachedPerToken != null) {
+        const uncachedTokens = inputTokens - cachedTokens;
+        return (uncachedTokens * pricing.inputPerToken +
+            cachedTokens * pricing.cachedPerToken +
+            outputTokens * pricing.outputPerToken);
+    }
     return inputTokens * pricing.inputPerToken + outputTokens * pricing.outputPerToken;
 }
 /** Get context window utilisation info. */
@@ -42,11 +48,11 @@ export function getContextInfo(messages, pricing) {
     };
 }
 /** Build a UsageInfo from actual or estimated token counts. */
-export function createUsageInfo(inputTokens, outputTokens, pricing) {
+export function createUsageInfo(inputTokens, outputTokens, pricing, cachedTokens) {
     return {
         inputTokens,
         outputTokens,
         totalTokens: inputTokens + outputTokens,
-        estimatedCost: calculateCost(inputTokens, outputTokens, pricing),
+        estimatedCost: calculateCost(inputTokens, outputTokens, pricing, cachedTokens),
     };
 }

package/dist/utils/file-time.js

@@ -42,15 +42,6 @@ export function checkReadBefore(sessionId, absolutePath) {
     }
     return null;
 }
-/**
- * @deprecated Use checkReadBefore instead — it returns a string rather than
- * throwing, so the error surfaces cleanly as a tool result.
- */
-export function assertReadBefore(sessionId, absolutePath) {
-    const err = checkReadBefore(sessionId, absolutePath);
-    if (err)
-        throw new Error(err);
-}
 /**
  * Clear all read-time entries for a session (e.g. on session end).
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "protoagent",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "type": "module",
   "files": [
     "dist",
@@ -20,8 +20,28 @@
     "docs:build": "vitepress build docs",
     "docs:preview": "vitepress preview docs"
   },
-  "author": "",
-  "license": "ISC",
+  "author": "Thomas Gauvin",
+  "license": "MIT",
+  "homepage": "https://protoagent.dev",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/thomasgauvin/protoagent.git"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "cli",
+    "coding-agent",
+    "llm",
+    "openai",
+    "anthropic",
+    "gemini",
+    "terminal",
+    "typescript"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
   "dependencies": {
     "@inkjs/ui": "^2.0.0",
     "@modelcontextprotocol/sdk": "^1.27.1",