protoagent 0.1.9 → 0.1.11

package/dist/agentic-loop.js

@@ -16,6 +16,7 @@
  * React state accordingly. This keeps the core logic testable
  * and UI-independent.
  */
+import { setMaxListeners } from 'node:events';
 import { getAllTools, handleToolCall } from './tools/index.js';
 import { generateSystemPrompt } from './system-prompt.js';
 import { subAgentTool, runSubAgent } from './sub-agent.js';
@@ -255,6 +256,17 @@ export async function runAgenticLoop(client, model, messages, userInput, onEvent
     const abortSignal = options.abortSignal;
     const sessionId = options.sessionId;
     const requestDefaults = options.requestDefaults || {};
+    // The same AbortSignal is passed into every OpenAI SDK call and every
+    // sleepWithAbort() across all loop iterations and sub-agent calls.
+    // The SDK attaches an 'abort' listener per request, so on a long run
+    // the default limit of 10 listeners is quickly exceeded, producing the
+    // MaxListenersExceededWarning.  AbortSignal is a Web API EventTarget,
+    // not a Node EventEmitter, so the instance method .setMaxListeners()
+    // doesn't exist on it — use the standalone setMaxListeners() from
+    // node:events instead, which handles both EventEmitter and EventTarget.
+    if (abortSignal) {
+        setMaxListeners(0, abortSignal); // 0 = unlimited, scoped to this signal only
+    }
     // Note: userInput is passed for context/logging but user message should already be in messages array
     // (added by the caller in handleSubmit for immediate UI display)
     const updatedMessages = [...messages];
@@ -267,6 +279,10 @@ export async function runAgenticLoop(client, model, messages, userInput, onEvent
     let iterationCount = 0;
     let repairRetryCount = 0;
     let contextRetryCount = 0;
+    let retriggerCount = 0;
+    let truncateRetryCount = 0;
+    const MAX_RETRIGGERS = 3;
+    const MAX_TRUNCATE_RETRIES = 5;
     const validToolNames = getValidToolNames();
     while (iterationCount < maxIterations) {
         // Check if abort was requested
@@ -286,14 +302,15 @@ export async function runAgenticLoop(client, model, messages, userInput, onEvent
                 updatedMessages.push(...compacted);
             }
         }
+        // Declare assistantMessage outside try block so it's accessible in catch
+        let assistantMessage;
         try {
             // Build tools list: core tools + sub-agent tool + dynamic (MCP) tools
             const allTools = [...getAllTools(), subAgentTool];
-            logger.debug('Making API request', {
+            logger.info('Making API request', {
                 model,
                 toolsCount: allTools.length,
                 messagesCount: updatedMessages.length,
-                toolNames: allTools.map((t) => t.function?.name).join(', '),
             });
             // Log message structure for debugging provider compatibility
             for (const msg of updatedMessages) {
@@ -335,7 +352,7 @@ export async function runAgenticLoop(client, model, messages, userInput, onEvent
                 signal: abortSignal,
             });
             // Accumulate the streamed response
-            const assistantMessage = {
+            assistantMessage = {
                 role: 'assistant',
                 content: '',
                 tool_calls: [],
@@ -387,23 +404,47 @@ export async function runAgenticLoop(client, model, messages, userInput, onEvent
                     }
                 }
             }
-            // Emit usage info — always emit, even without pricing (use estimates)
+            // Log API response with usage info at INFO level
             {
                 const inputTokens = actualUsage?.prompt_tokens ?? estimateConversationTokens(updatedMessages);
                 const outputTokens = actualUsage?.completion_tokens ?? estimateTokens(assistantMessage.content || '');
+                const cachedTokens = actualUsage?.prompt_tokens_details?.cached_tokens;
                 const cost = pricing
-                    ? createUsageInfo(inputTokens, outputTokens, pricing).estimatedCost
+                    ? createUsageInfo(inputTokens, outputTokens, pricing, cachedTokens).estimatedCost
                     : 0;
                 const contextPercent = pricing
                     ? getContextInfo(updatedMessages, pricing).utilizationPercentage
                     : 0;
+                logger.info('Received API response', {
+                    model,
+                    inputTokens,
+                    outputTokens,
+                    cachedTokens,
+                    cost: cost > 0 ? `$${cost.toFixed(4)}` : 'N/A',
+                    contextPercent: contextPercent > 0 ? `${contextPercent.toFixed(1)}%` : 'N/A',
+                    hasToolCalls: assistantMessage.tool_calls.length > 0,
+                    contentLength: assistantMessage.content?.length || 0,
+                });
                 onEvent({
                     type: 'usage',
                     usage: { inputTokens, outputTokens, cost, contextPercent },
                 });
             }
+            // Log the full assistant message for debugging
+            logger.debug('Assistant response details', {
+                contentLength: assistantMessage.content?.length || 0,
+                contentPreview: assistantMessage.content?.slice(0, 200) || '(empty)',
+                toolCallsCount: assistantMessage.tool_calls?.length || 0,
+                toolCalls: assistantMessage.tool_calls?.map((tc) => ({
+                    id: tc.id,
+                    name: tc.function?.name,
+                    argsPreview: tc.function?.arguments?.slice(0, 100),
+                })),
+            });
             // Handle tool calls
             if (assistantMessage.tool_calls.length > 0) {
+                // Reset retrigger count on valid tool call response
+                retriggerCount = 0;
                 // Clean up empty tool_calls entries (from sparse array)
                 assistantMessage.tool_calls = assistantMessage.tool_calls.filter(Boolean);
                 assistantMessage.tool_calls = assistantMessage.tool_calls.map((toolCall) => {
@@ -416,13 +457,33 @@ export async function runAgenticLoop(client, model, messages, userInput, onEvent
                     }
                     return sanitized.toolCall;
                 });
-                logger.debug('Model returned tool calls', {
+                // Validate that all tool calls have valid JSON arguments
+                const invalidToolCalls = assistantMessage.tool_calls.filter((tc) => {
+                    const args = tc.function?.arguments;
+                    if (!args)
+                        return false; // Empty args is valid
+                    try {
+                        JSON.parse(args);
+                        return false; // Valid JSON
+                    }
+                    catch {
+                        return true; // Invalid JSON
+                    }
+                });
+                if (invalidToolCalls.length > 0) {
+                    logger.warn('Assistant produced tool calls with invalid JSON, skipping this turn', {
+                        invalidToolCalls: invalidToolCalls.map((tc) => ({
+                            name: tc.function?.name,
+                            argsPreview: tc.function?.arguments?.slice(0, 100),
+                        })),
+                    });
+                    // Don't add the malformed assistant message to conversation
+                    // The loop will continue and retry
+                    continue;
+                }
+                logger.info('Model returned tool calls', {
                     count: assistantMessage.tool_calls.length,
-                    calls: assistantMessage.tool_calls.map((tc) => ({
-                        id: tc.id,
-                        name: tc.function?.name,
-                        argsPreview: tc.function?.arguments?.slice(0, 100),
-                    })),
+                    tools: assistantMessage.tool_calls.map((tc) => tc.function?.name).join(', '),
                 });
                 updatedMessages.push(assistantMessage);
                 // Track which tool_call_ids still need a tool result message.
@@ -459,19 +520,25 @@ export async function runAgenticLoop(client, model, messages, userInput, onEvent
                             const subProgress = (evt) => {
                                 onEvent({
                                     type: 'sub_agent_iteration',
-                                    subAgentTool: { tool: evt.tool, status: evt.status, iteration: evt.iteration },
+                                    subAgentTool: { tool: evt.tool, status: evt.status, iteration: evt.iteration, args: evt.args },
                                 });
                             };
-                            result = await runSubAgent(client, model, args.task, args.max_iterations, requestDefaults, subProgress, abortSignal);
+                            const subResult = await runSubAgent(client, model, args.task, args.max_iterations, requestDefaults, subProgress, abortSignal, pricing);
+                            result = subResult.response;
+                            // Emit sub-agent usage for the UI to add to total cost
+                            if (subResult.usage.inputTokens > 0 || subResult.usage.outputTokens > 0) {
+                                onEvent({
+                                    type: 'sub_agent_iteration',
+                                    subAgentUsage: subResult.usage,
+                                });
+                            }
                         }
                         else {
                             result = await handleToolCall(name, args, { sessionId, abortSignal });
                         }
-                        logger.debug('Tool result', {
+                        logger.info('Tool completed', {
                             tool: name,
-                            tool_call_id: toolCall.id,
                             resultLength: result.length,
-                            resultPreview: result.slice(0, 200),
                         });
                         updatedMessages.push({
                             role: 'tool',
@@ -517,14 +584,67 @@ export async function runAgenticLoop(client, model, messages, userInput, onEvent
                     role: 'assistant',
                     content: assistantMessage.content,
                 });
+                // Reset retrigger count on valid content response
+                retriggerCount = 0;
+            }
+            // Check if we need to retrigger: if the last message is a tool result
+            // but we got no assistant response (empty content, no tool_calls), the AI
+            // may have stopped prematurely. Inject a 'continue' prompt and retry.
+            const lastMessage = updatedMessages[updatedMessages.length - 1];
+            if (lastMessage?.role === 'tool' && retriggerCount < MAX_RETRIGGERS) {
+                retriggerCount++;
+                logger.warn('AI stopped after tool call without responding; retriggering', {
+                    retriggerCount,
+                    maxRetriggers: MAX_RETRIGGERS,
+                    lastMessageRole: lastMessage.role,
+                    assistantContent: assistantMessage.content || '(empty)',
+                    hasToolCalls: assistantMessage.tool_calls.length > 0,
+                });
+                // Inject a 'continue' prompt to help the AI continue
+                updatedMessages.push({
+                    role: 'user',
+                    content: 'Please continue.',
+                });
+                continue;
             }
             repairRetryCount = 0;
+            retriggerCount = 0;
             onEvent({ type: 'done' });
             return updatedMessages;
         }
         catch (apiError) {
             if (abortSignal?.aborted || apiError?.name === 'AbortError' || apiError?.message === 'Operation aborted') {
                 logger.debug('Agentic loop request aborted');
+                // If we have a partial assistant message with tool_calls, we need to
+                // add it to the conversation history before returning, otherwise the
+                // message sequence will be invalid (tool results without assistant tool_calls).
+                if (assistantMessage && (assistantMessage.content || assistantMessage.tool_calls?.length > 0)) {
+                    // Clean up empty tool_calls entries
+                    if (assistantMessage.tool_calls?.length > 0) {
+                        assistantMessage.tool_calls = assistantMessage.tool_calls.filter(Boolean);
+                        // Filter out tool calls with malformed/incomplete JSON arguments
+                        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; // Valid JSON
+                            }
+                            catch {
+                                logger.warn('Filtering out tool call with malformed JSON arguments due to abort', {
+                                    tool: tc.function?.name,
+                                    argsPreview: args.slice(0, 100),
+                                });
+                                return false; // Invalid JSON, filter out
+                            }
+                        });
+                    }
+                    // Only add the assistant message if we have content or valid tool calls
+                    if (assistantMessage.content || assistantMessage.tool_calls?.length > 0) {
+                        updatedMessages.push(assistantMessage);
+                    }
+                }
                 emitAbortAndFinish(onEvent);
                 return updatedMessages;
             }
@@ -557,21 +677,42 @@ export async function runAgenticLoop(client, model, messages, userInput, onEvent
             });
             const retryableStatus = apiError?.status === 408 || apiError?.status === 409 || apiError?.status === 425;
             const retryableCode = ['ECONNRESET', 'ECONNABORTED', 'ETIMEDOUT', 'ENETUNREACH', 'EAI_AGAIN'].includes(apiError?.code);
-            if (apiError?.status === 400 && repairRetryCount < 2) {
-                const sanitized = sanitizeMessagesForRetry(updatedMessages, getValidToolNames());
-                if (sanitized.changed) {
-                    repairRetryCount++;
-                    updatedMessages.length = 0;
-                    updatedMessages.push(...sanitized.messages);
-                    logger.warn('400 response after malformed tool payload; retrying with sanitized messages', {
-                        repairRetryCount,
-                    });
-                    onEvent({
-                        type: 'error',
-                        error: 'Provider rejected the tool payload. Repairing the request and retrying...',
-                        transient: true,
-                    });
-                    continue;
+            // Handle 400 errors: try sanitization first, then truncate messages
+            if (apiError?.status === 400) {
+                // Try sanitization first
+                if (repairRetryCount < 2) {
+                    const sanitized = sanitizeMessagesForRetry(updatedMessages, getValidToolNames());
+                    if (sanitized.changed) {
+                        repairRetryCount++;
+                        updatedMessages.length = 0;
+                        updatedMessages.push(...sanitized.messages);
+                        logger.warn('400 response after malformed tool payload; retrying with sanitized messages', {
+                            repairRetryCount,
+                        });
+                        // Silently retry without showing error to user
+                        continue;
+                    }
+                }
+                // If sanitization didn't help, try removing messages one at a time (up to 5)
+                if (truncateRetryCount < MAX_TRUNCATE_RETRIES) {
+                    truncateRetryCount++;
+                    const removedCount = Math.min(1, Math.max(0, updatedMessages.length - 2)); // Remove 1 at a time, keep system + at least 1 user
+                    if (removedCount > 0) {
+                        const removed = updatedMessages.splice(-removedCount);
+                        logger.debug('400 error: removing message from history to attempt fix', {
+                            truncateRetryCount,
+                            maxRetries: MAX_TRUNCATE_RETRIES,
+                            removedCount,
+                            removedRoles: removed.map((m) => m.role),
+                            removedPreviews: removed.map((m) => ({
+                                role: m.role,
+                                content: m.content?.slice(0, 100),
+                                tool_calls: m.tool_calls?.map((tc) => tc.function?.name),
+                            })),
+                        });
+                        // Silently retry without showing error to user
+                        continue;
+                    }
                 }
             }
             // Handle context-window-exceeded (prompt too long) — attempt forced compaction
@@ -633,6 +774,16 @@ export async function runAgenticLoop(client, model, messages, userInput, onEvent
                 await sleepWithAbort(backoff, abortSignal);
                 continue;
             }
+            // 400 error that couldn't be fixed by sanitization or truncation
+            if (apiError?.status === 400) {
+                onEvent({
+                    type: 'error',
+                    error: 'The conversation history appears to be corrupted and could not be automatically repaired. Try /clear to start fresh.',
+                    transient: false,
+                });
+                onEvent({ type: 'done' });
+                return updatedMessages;
+            }
             // Non-retryable error
             onEvent({ type: 'error', error: errMsg });
             onEvent({ type: 'done' });

package/dist/cli.js

@@ -22,12 +22,12 @@ const program = new Command();
 program
     .description('ProtoAgent — a simple, hackable coding agent CLI')
     .version(packageJson.version)
-    .option('--dangerously-accept-all', 'Auto-approve all file writes and shell commands')
-    .option('--log-level <level>', 'Log level: TRACE, DEBUG, INFO, WARN, ERROR', 'INFO')
+    .option('--dangerously-skip-permissions', 'Auto-approve all file writes and shell commands')
+    .option('--log-level <level>', 'Log level: TRACE, DEBUG, INFO, WARN, ERROR', 'DEBUG')
     .option('--session <id>', 'Resume a previous session by ID')
     .action((options) => {
     // Default action - start the main app
-    render(_jsx(App, { dangerouslyAcceptAll: options.dangerouslyAcceptAll || false, logLevel: options.logLevel, sessionId: options.session }));
+    render(_jsx(App, { dangerouslySkipPermissions: options.dangerouslySkipPermissions || false, logLevel: options.logLevel, sessionId: options.session }));
 });
 // Configure subcommand
 program

package/dist/config.js

@@ -16,21 +16,24 @@ function hardenPermissions(targetPath, mode) {
     chmodSync(targetPath, mode);
 }
 export function resolveApiKey(config) {
-    const directApiKey = config.apiKey?.trim();
-    if (directApiKey) {
-        return directApiKey;
-    }
     const provider = getProvider(config.provider);
+    // 1. Provider-specific environment variable
     if (provider?.apiKeyEnvVar) {
         const providerEnvOverride = process.env[provider.apiKeyEnvVar]?.trim();
         if (providerEnvOverride) {
             return providerEnvOverride;
         }
     }
+    // 2. Generic environment variable
     const envOverride = process.env.PROTOAGENT_API_KEY?.trim();
     if (envOverride) {
         return envOverride;
     }
+    // 3. Config file (either from selected provider or direct apiKey)
+    const directApiKey = config.apiKey?.trim();
+    if (directApiKey) {
+        return directApiKey;
+    }
     const providerApiKey = provider?.apiKey?.trim();
     if (providerApiKey) {
         return providerApiKey;
@@ -84,9 +87,47 @@ const RUNTIME_CONFIG_TEMPLATE = `{
   // - custom providers/models
   // - MCP server definitions
   // - request default parameters
-  "providers": {},
+  "providers": {
+    // "provider-id": {
+    //   "name": "Display Name",
+    //   "baseURL": "https://api.example.com/v1",
+    //   "apiKey": "your-api-key",
+    //   "apiKeyEnvVar": "ENV_VAR_NAME",
+    //   "headers": {
+    //     "X-Custom-Header": "value"
+    //   },
+    //   "defaultParams": {},
+    //   "models": {
+    //     "model-id": {
+    //       "name": "Display Name",
+    //       "contextWindow": 128000,
+    //       "inputPricePerMillion": 2.5,
+    //       "outputPricePerMillion": 10.0,
+    //       "cachedPricePerMillion": 1.25,
+    //       "defaultParams": {}
+    //     }
+    //   }
+    // }
+  },
   "mcp": {
-    "servers": {}
+    "servers": {
+      // "server-name": {
+      //   "type": "stdio",
+      //   "command": "npx",
+      //   "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/dir"],
+      //   "env": { "KEY": "value" },
+      //   "cwd": "/working/directory",
+      //   "enabled": true,
+      //   "timeoutMs": 30000
+      // },
+      // "http-server": {
+      //   "type": "http",
+      //   "url": "https://mcp-server.example.com",
+      //   "headers": { "Authorization": "Bearer token" },
+      //   "enabled": true,
+      //   "timeoutMs": 30000
+      // }
+    }
   }
 }
 `;
@@ -215,7 +256,13 @@ export const ResetPrompt = ({ existingConfig, setStep, setConfigWritten }) => {
                     }
                 } })] }));
 };
-export const ModelSelection = ({ setSelectedProviderId, setSelectedModelId, setStep, }) => {
+export const TargetSelection = ({ title, subtitle, onSelect, }) => {
+    return (_jsxs(Box, { flexDirection: "column", children: [title && _jsx(Text, { color: "green", bold: true, children: title }), subtitle && _jsx(Text, { children: subtitle }), _jsx(Box, { marginTop: 1, children: _jsx(Select, { options: [
+                        { label: `Project config — ${getProjectRuntimeConfigPath()}`, value: 'project' },
+                        { label: `Shared user config — ${getUserRuntimeConfigPath()}`, value: 'user' },
+                    ], onChange: (value) => onSelect(value) }) })] }));
+};
+export const ModelSelection = ({ setSelectedProviderId, setSelectedModelId, onSelect, setStep, title, }) => {
     const items = getAllProviders().flatMap((provider) => provider.models.map((model) => ({
         label: `${provider.name} - ${model.name}`,
         value: `${provider.id}:::${model.id}`,
@@ -224,11 +271,16 @@ export const ModelSelection = ({ setSelectedProviderId, setSelectedModelId, setS
         const [providerId, modelId] = value.split(':::');
         setSelectedProviderId(providerId);
         setSelectedModelId(modelId);
-        setStep(3);
+        if (onSelect) {
+            onSelect(providerId, modelId);
+        }
+        else {
+            setStep?.(3);
+        }
     };
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "Select an AI Model:" }), _jsx(Select, { options: items, onChange: handleSelect })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [title && _jsx(Text, { color: "green", bold: true, children: title }), _jsx(Text, { children: "Select an AI Model:" }), _jsx(Select, { options: items, onChange: handleSelect })] }));
 };
-export const ApiKeyInput = ({ selectedProviderId, selectedModelId, target, setStep, setConfigWritten, }) => {
+export const ApiKeyInput = ({ selectedProviderId, selectedModelId, target = 'user', title, showProviderHeaders = true, onComplete, setStep, setConfigWritten, }) => {
     const [errorMessage, setErrorMessage] = useState('');
     const provider = getProvider(selectedProviderId);
     const canUseResolvedAuth = Boolean(resolveApiKey({ provider: selectedProviderId, apiKey: undefined }));
@@ -243,10 +295,15 @@ export const ApiKeyInput = ({ selectedProviderId, selectedModelId, target, setSt
             ...(value.trim().length > 0 ? { apiKey: value.trim() } : {}),
         };
         writeConfig(newConfig, target);
-        setConfigWritten(true);
-        setStep(4);
+        if (onComplete) {
+            onComplete(newConfig);
+        }
+        else {
+            setConfigWritten?.(true);
+            setStep?.(4);
+        }
     };
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: [canUseResolvedAuth ? 'Optional API Key' : 'Enter API Key', " for ", provider?.name || selectedProviderId, ":"] }), provider?.headers && Object.keys(provider.headers).length > 0 && (_jsx(Text, { dimColor: true, children: "This provider can authenticate with configured headers or environment variables." })), errorMessage && _jsx(Text, { color: "red", children: errorMessage }), _jsx(PasswordInput, { placeholder: canUseResolvedAuth ? 'Press enter to keep resolved auth' : `Enter your ${provider?.apiKeyEnvVar || 'API'} key`, onSubmit: handleApiKeySubmit })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [title && _jsx(Text, { color: "green", bold: true, children: title }), _jsxs(Text, { children: [canUseResolvedAuth ? 'Optional API Key' : 'Enter API Key', " for ", provider?.name || selectedProviderId, ":"] }), showProviderHeaders && provider?.headers && Object.keys(provider.headers).length > 0 && (_jsx(Text, { dimColor: true, children: "This provider can authenticate with configured headers or environment variables." })), errorMessage && _jsx(Text, { color: "red", children: errorMessage }), _jsx(PasswordInput, { placeholder: canUseResolvedAuth ? 'Press enter to keep resolved auth' : `Enter your ${provider?.apiKeyEnvVar || 'API'} key`, onSubmit: handleApiKeySubmit })] }));
 };
 export const ConfigResult = ({ configWritten }) => {
     return (_jsxs(Box, { flexDirection: "column", children: [configWritten ? (_jsx(Text, { color: "green", children: "Configuration saved successfully!" })) : (_jsx(Text, { color: "yellow", children: "Configuration not changed." })), _jsx(Text, { children: "You can now run ProtoAgent." })] }));
@@ -259,15 +316,12 @@ export const ConfigureComponent = () => {
     const [selectedModelId, setSelectedModelId] = useState('');
     const [configWritten, setConfigWritten] = useState(false);
     if (step === 0) {
-        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "Choose where to configure ProtoAgent:" }), _jsx(Box, { marginTop: 1, children: _jsx(Select, { options: [
-                            { label: `Project config — ${getProjectRuntimeConfigPath()}`, value: 'project' },
-                            { label: `Shared user config — ${getUserRuntimeConfigPath()}`, value: 'user' },
-                        ], onChange: (value) => {
-                            setTarget(value);
-                            const existing = readConfig(value);
-                            setExistingConfig(existing);
-                            setStep(existing ? 1 : 2);
-                        } }) })] }));
+        return (_jsx(TargetSelection, { subtitle: "Choose where to configure ProtoAgent:", onSelect: (value) => {
+                setTarget(value);
+                const existing = readConfig(value);
+                setExistingConfig(existing);
+                setStep(existing ? 1 : 2);
+            } }));
     }
     switch (step) {
         case 1:

package/dist/mcp.js

@@ -42,6 +42,7 @@ async function connectStdioServer(serverName, config) {
             ...(config.env || {}),
         },
         cwd: config.cwd,
+        stderr: 'pipe',
     });
     const client = new Client({
         name: 'protoagent',
@@ -50,6 +51,14 @@ async function connectStdioServer(serverName, config) {
         capabilities: {},
     });
     await client.connect(transport);
+    // Pipe stderr from the spawned process to the logger instead of letting it
+    // bleed through to the terminal and corrupt the Ink UI.
+    transport.stderr?.on('data', (data) => {
+        for (const line of data.toString('utf-8').split('\n')) {
+            if (line.trim())
+                logger.debug(`MCP [${serverName}] ${line}`);
+        }
+    });
     return {
         client,
         serverName,
@@ -169,3 +178,9 @@ export async function closeMcp() {
     }
     connections.clear();
 }
+/**
+ * Get the names of all connected MCP servers.
+ */
+export function getConnectedMcpServers() {
+    return Array.from(connections.keys());
+}

package/dist/providers.js

@@ -11,9 +11,9 @@ export const BUILTIN_PROVIDERS = [
         name: 'OpenAI',
         apiKeyEnvVar: 'OPENAI_API_KEY',
         models: [
-            { id: 'gpt-5.2', name: 'GPT-5.2', contextWindow: 200_000, pricingPerMillionInput: 6.0, pricingPerMillionOutput: 24.0 },
-            { id: 'gpt-5-mini', name: 'GPT-5 Mini', contextWindow: 200_000, pricingPerMillionInput: 0.15, pricingPerMillionOutput: 0.6 },
-            { id: 'gpt-4.1', name: 'GPT-4.1', contextWindow: 128_000, pricingPerMillionInput: 2.5, pricingPerMillionOutput: 10.0 },
+            { id: 'gpt-5.4', name: 'GPT-5.4', contextWindow: 1_048_576, pricingPerMillionInput: 2.50, pricingPerMillionOutput: 15.00 },
+            { id: 'gpt-5-mini', name: 'GPT-5 Mini', contextWindow: 1_000_000, pricingPerMillionInput: 0.25, pricingPerMillionOutput: 2.00 },
+            { id: 'gpt-4.1', name: 'GPT-4.1', contextWindow: 1_048_576, pricingPerMillionInput: 2.0, pricingPerMillionOutput: 8.00 },
         ],
     },
     {
@@ -33,21 +33,12 @@ export const BUILTIN_PROVIDERS = [
         baseURL: 'https://generativelanguage.googleapis.com/v1beta/openai/',
         apiKeyEnvVar: 'GEMINI_API_KEY',
         models: [
-            { id: 'gemini-3-flash-preview', name: 'Gemini 3 Flash (Preview)', contextWindow: 1_000_000, pricingPerMillionInput: 0.075, pricingPerMillionOutput: 0.3 },
-            { id: 'gemini-3-pro-preview', name: 'Gemini 3 Pro (Preview)', contextWindow: 1_000_000, pricingPerMillionInput: 1.25, pricingPerMillionOutput: 10.0 },
-            { id: 'gemini-2.5-flash', name: 'Gemini 2.5 Flash', contextWindow: 1_000_000, pricingPerMillionInput: 0.075, pricingPerMillionOutput: 0.3 },
+            { id: 'gemini-3-flash-preview', name: 'Gemini 3 Flash (Preview)', contextWindow: 1_000_000, pricingPerMillionInput: 0.50, pricingPerMillionOutput: 3.0 },
+            { id: 'gemini-3.1-pro-preview', name: 'Gemini 3.1 Pro (Preview)', contextWindow: 1_000_000, pricingPerMillionInput: 2.0, pricingPerMillionOutput: 12.0 },
+            { id: 'gemini-2.5-flash', name: 'Gemini 2.5 Flash', contextWindow: 1_000_000, pricingPerMillionInput: 0.30, pricingPerMillionOutput: 2.5 },
             { id: 'gemini-2.5-pro', name: 'Gemini 2.5 Pro', contextWindow: 1_000_000, pricingPerMillionInput: 1.25, pricingPerMillionOutput: 10.0 },
         ],
     },
-    {
-        id: 'cerebras',
-        name: 'Cerebras',
-        baseURL: 'https://api.cerebras.ai/v1',
-        apiKeyEnvVar: 'CEREBRAS_API_KEY',
-        models: [
-            { id: 'llama-4-scout-17b-16e-instruct', name: 'Llama 4 Scout 17B', contextWindow: 128_000, pricingPerMillionInput: 0.0, pricingPerMillionOutput: 0.0 },
-        ],
-    },
 ];
 function sanitizeDefaultParams(defaultParams) {
     if (!defaultParams || Object.keys(defaultParams).length === 0)
@@ -67,6 +58,7 @@ function mergeModelLists(baseModels, overrideModels) {
             contextWindow: override.contextWindow ?? current?.contextWindow ?? 0,
             pricingPerMillionInput: override.inputPricePerMillion ?? current?.pricingPerMillionInput ?? 0,
             pricingPerMillionOutput: override.outputPricePerMillion ?? current?.pricingPerMillionOutput ?? 0,
+            pricingPerMillionCached: override.cachedPricePerMillion ?? current?.pricingPerMillionCached,
             defaultParams: sanitizeDefaultParams({
                 ...(current?.defaultParams || {}),
                 ...(override.defaultParams || {}),
@@ -109,6 +101,7 @@ export function getModelPricing(providerId, modelId) {
     return {
         inputPerToken: details.pricingPerMillionInput / 1_000_000,
         outputPerToken: details.pricingPerMillionOutput / 1_000_000,
+        cachedPerToken: details.pricingPerMillionCached != null ? details.pricingPerMillionCached / 1_000_000 : undefined,
         contextWindow: details.contextWindow,
     };
 }

package/dist/sessions.js

@@ -9,22 +9,32 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
-import crypto from 'node:crypto';
 import { chmodSync } from 'node:fs';
 import { logger } from './utils/logger.js';
 const SESSION_DIR_MODE = 0o700;
 const SESSION_FILE_MODE = 0o600;
 const SESSION_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const SHORT_ID_PATTERN = /^[0-9a-z]{8}$/i;
 function hardenPermissions(targetPath, mode) {
     if (process.platform === 'win32')
         return;
     chmodSync(targetPath, mode);
 }
 function assertValidSessionId(id) {
-    if (!SESSION_ID_PATTERN.test(id)) {
+    // Accept both legacy UUIDs and new short IDs
+    if (!SESSION_ID_PATTERN.test(id) && !SHORT_ID_PATTERN.test(id)) {
         throw new Error(`Invalid session ID: ${id}`);
     }
 }
+/** Generate a short, readable session ID (8 alphanumeric characters). */
+function generateSessionId() {
+    const chars = '0123456789abcdefghijklmnopqrstuvwxyz';
+    let id = '';
+    for (let i = 0; i < 8; i++) {
+        id += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return id;
+}
 export function ensureSystemPromptAtTop(messages, systemPrompt) {
     const firstSystemIndex = messages.findIndex((message) => message.role === 'system');
     if (firstSystemIndex === -1) {
@@ -62,7 +72,7 @@ function sessionPath(id) {
 /** Create a new session. */
 export function createSession(model, provider) {
     return {
-        id: crypto.randomUUID(),
+        id: generateSessionId(),
         title: 'New session',
         createdAt: new Date().toISOString(),
         updatedAt: new Date().toISOString(),

package/dist/skills.js

@@ -36,6 +36,7 @@ function parseFrontmatter(rawContent) {
 function isValidSkillName(name) {
     return name.length >= 1 && name.length <= 64 && VALID_SKILL_NAME.test(name);
 }
+// normalizeMetadata ensures the metadata field is an object with string values, or undefined if not provided or invalid
 function normalizeMetadata(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
         return undefined;
@@ -89,7 +90,7 @@ async function loadSkillFromDirectory(skillDir, source) {
         const rawContent = await fs.readFile(location, 'utf8');
         const parsed = parseFrontmatter(rawContent);
         const skill = validateSkill(parsed, skillDir, source, location);
-        logger.debug(`Loaded skill: ${skill.name} (${source})`, { location });
+        logger.info(`Loaded skill: ${skill.name} (${source})`, { location });
         return skill;
     }
     catch (error) {