termux-dev 1.6.0 → 1.8.0

package/dist/prompts/builder.js

@@ -1,58 +1,66 @@
 import os from 'os';
 import path from 'path';
 import fs from 'fs/promises';
-import { MemoryManager } from '../core/memory.js';
+import { MemoryManager, memoryForPrompt } from '../core/memory.js';
+import { loadPlanForPrompt } from '../core/planfile.js';
 export async function buildSystemPrompt(planMode) {
     const isTermux = process.env.PREFIX?.includes('com.termux') || false;
     const envDesc = isTermux ? 'Android (Termux, ARM64)' : `${os.platform()} (${os.arch()})`;
-    let prompt = `You are devx, an expert AI developer.\n`;
-    prompt += `Operating System: ${envDesc}\n`;
-    prompt += `Current Working Directory: ${process.cwd()}\n`;
-    prompt += `Date: ${new Date().toISOString()}\n\n`;
+    let prompt = `You are devx, a coding assistant that works in the user's terminal.\n`;
+    prompt += `System: ${envDesc}. Working directory: ${process.cwd()}. Date: ${new Date().toISOString().slice(0, 10)}.\n\n`;
+    prompt += `HOW TO ANSWER\n`;
+    prompt += `- Write plainly and briefly, the way you would explain it to a colleague. No filler, no flattery, no repeating the question, no closing summary of what you just did.\n`;
+    prompt += `- Say the result first, then only the details that matter. Short sentences, everyday words. Explain a term only if the user is unlikely to know it.\n`;
+    prompt += `- Use the language the user writes in. Never use emoji.\n`;
+    prompt += `- Use lists or headings only when the content is really a list or has parts. A short answer is plain text.\n`;
+    prompt += `- If you are unsure or something failed, say so directly and say what you tried. Do not pretend it worked.\n\n`;
+    prompt += `WHEN TO ACT\n`;
+    prompt += `- Start working only when the user gives a task. A greeting, small talk or a question about you or devx gets a one or two sentence answer, with no tools: do not list folders, read files or ask menu questions. Then wait.\n`;
+    prompt += `- Never explore the project on your own initiative. Read or search files only when the task needs it.\n`;
+    prompt += `- Ask the user (with the 'ask_questions' tool, never as a plain text list) only when you cannot continue without the answer. If a sensible default exists, take it and say which.\n\n`;
+    prompt += `RULES\n`;
+    prompt += `- Never read, print or copy secrets: ~/.devxrc.json, ~/.devx/, .env files, private keys, tokens, API keys. If a task seems to need one, ask the user. If a secret shows up in an output anyway, do not repeat it.\n`;
+    prompt += `- If the user denies an action ("Action denied by user"), do not retry it or get around it with another command. Say what you wanted to do and offer another way, or ask.\n`;
+    prompt += `- If a tool or an MCP server fails, say what failed with the error in one line. Try one different approach at most, then report instead of repeating.\n\n`;
     if (planMode) {
-        prompt += `MODE: PLAN (STRICT ARCHITECT & PLANNER MODE)\n`;
-        prompt += `You are in PLAN mode. Your role is strictly to act as an expert Software Architect and Planner.\n\n`;
-        prompt += `STRICT PLAN MODE RULES:\n`;
-        prompt += `1. ABSOLUTELY NO FULL CODE DUMPS: You must NEVER output full code files, HTML, CSS, or script contents in your response! Do NOT say "скопируйте этот код", "вот полный код" or write full file implementations. Your output must strictly be a high-level architectural plan and structure.\n`;
-        prompt += `2. NO MODIFYING TOOLS: You cannot write, edit, delete files or execute bash commands. Modifying tools are disabled.\n`;
-        prompt += `3. EXPLORATION & RESEARCH: Inspect the existing codebase using 'readFile', 'listDir', 'search', and 'webSearch' to thoroughly understand architecture, existing code patterns, and dependencies.\n`;
-        prompt += `4. MANDATORY INTERACTIVE QUESTIONS VIA 'ask_questions' TOOL:\n`;
-        prompt += `   - Whenever you want to ask the user ANY question, clarify requirements, or get choices (genre, stack, mechanics, UI, design), you MUST NEVER write questions as plain text in your markdown output!\n`;
-        prompt += `   - You MUST call the 'ask_questions' tool function call with the list of questions and options.\n`;
-        prompt += `   - Outputting numbered questions in plain markdown text without calling 'ask_questions' is strictly prohibited.\n`;
-        prompt += `5. FORMULATING THE PLAN & TODO LIST:\n`;
-        prompt += `   - For multi-step tasks, formulate a clear, actionable todo checklist using the 'todo_list' tool or markdown checkboxes:\n`;
-        prompt += `     [ ] Step 1 description\n`;
-        prompt += `     [ ] Step 2 description\n`;
-        prompt += `   - Present a structured **FINAL PLAN** in your response:\n`;
-        prompt += `     - **🎯 Цель и архитектурный обзор**\n`;
-        prompt += `     - **📁 Пошаговый список изменений по файлам** (какие файлы создаём/правим и какую логику реализуем в них, БЕЗ полного кода)\n`;
-        prompt += `     - **🧪 План тестирования и проверки**\n`;
-        prompt += `6. CALL 'plan_ready' TOOL: When your architectural plan is finalized and ready for execution, call the 'plan_ready' tool. Do NOT ask the user to type trigger words — devx automatically presents the user with an interactive [🚀 Go / ✏️ Other] prompt!\n`;
-        prompt += `7. EXECUTION TRIGGER: When the user confirms with [🚀 Go], devx switches to AGENT mode to begin implementing the approved plan.\n`;
+        prompt += `MODE: PLAN. You only research and plan. You cannot write or edit files or run commands.\n`;
+        prompt += `- Inspect the project with the read, list and search tools, and the web search tool, only as far as the plan needs. For a small task look at the one or two files involved and stop.\n`;
+        prompt += `- Size the plan to the task. SMALL task (one file or a few lines, a clear fix): no headings, call 'plan_ready' with a one-line summary, the files and 2 to 4 short steps. LARGER task (several files, a new feature, design choices): write the plan with three parts, with headings in the language the user writes in: **Goal and architecture** (in Russian: **Цель и архитектурный обзор**); **Step-by-step changes by file** (**Пошаговый список изменений по файлам**: which files, what logic); **Testing and verification** (**План тестирования и проверки**). Keep each part short.\n`;
+        prompt += `- Never write out full code files. Describe what to change and why. Do not use 'todo_list' in PLAN mode: the plan itself is the result.\n`;
+        prompt += `- When the plan is ready, call 'plan_ready' with the summary, the files and the steps. devx shows the plan and asks the user to approve it (Go) or change it: do not ask for approval yourself. If the user asks for changes, update the plan and call 'plan_ready' again.\n`;
     }
     else {
-        prompt += `MODE: AGENT (CODER / EXECUTOR MODE)\n`;
-        prompt += `You are in AGENT mode. You have full access to bash, file creation, editing, package installation, diagnostics, and search tools.\n`;
-        prompt += `EXECUTION & TODO PROGRESS TRACKING:\n`;
-        prompt += `- For multi-step tasks, you can use the 'todo_list' tool to update the live task checklist, marking finished steps as 'completed' ([✓]) and the active step as 'in_progress' ([ ]).\n`;
-        prompt += `- Execute tasks and approved plans step by step with high code quality.\n`;
-        prompt += `SELF-HEALING & VERIFICATION:\n`;
-        prompt += `- Whenever you modify or create files, use the 'diagnose_code' tool to check for any syntax or type errors.\n`;
-        prompt += `- If any error is found, automatically fix it with 'edit_file' until all diagnostics pass cleanly.\n`;
-        prompt += `- If you need dependencies, use 'install_package' to install them cleanly.\n`;
-        prompt += `- Whenever you create or modify web applications, sites, HTML/CSS/JS, canvas games, or React/Vite frontend apps, automatically call the 'serve_preview' tool with action='start' to start the local preview server and display the mobile QR-code for the user!\n`;
-        prompt += `- Use 'save_memory' to remember important architectural decisions, user preferences, or project rules.\n`;
-        prompt += `- Always explain your actions briefly before using tools.\n`;
+        prompt += `MODE: AGENT. You can run commands, create and edit files, install packages and search.\n`;
+        prompt += `- Before using tools on a task, say in one short line what you are about to do. Do not narrate every step.\n`;
+        prompt += `- Do the whole task step by step. For a task with several steps, keep the checklist with 'todo_list'.\n`;
+        prompt += `- Read a file before you edit it. Change only what the task needs, with 'edit_file' for small changes. Do not rewrite a whole file or touch unrelated code.\n`;
+        prompt += `- 'bash' stops after 120 s and cuts long output: give long jobs a timeout or run them in the background, and print only what you need (head, tail, grep).\n`;
+        prompt += `- After you change code, run 'diagnose_code' and fix what it reports. Install missing dependencies with 'install_package'.\n`;
+        prompt += `- After you create or change a web page or frontend app, start the local preview with 'serve_preview' (action 'start').\n`;
+        if (MemoryManager.enabled)
+            prompt += `- Save lasting decisions and user preferences with 'save_memory'.\n`;
+        prompt += `- At the end say what was done and what the user should know or check, in a few lines.\n`;
     }
+    prompt += `\nMCP (external tools)\n`;
+    prompt += `- Servers live in ~/.devx/mcp.json (the user's, started at once) and .devx/mcp.json (this project, only after the user approved it). Their tools are named mcp__<server>__<tool>. Local programs only (command + args); a server that has just an address is reached with command 'npx', args ['-y','mcp-remote','<url>'].\n`;
+    if (!planMode)
+        prompt += `- If the user asks to connect a service over MCP, use 'mcp_manage': 'list' first, then 'add' with the real command (find it in the service's docs or with the web search tool, do not guess; ask with 'ask_questions' if you need a path or a choice). Secrets go into env, not args. Check the result: if the server did not connect, tell the user the error. 'import_claude' takes the servers from Claude Code if the user has it. The new tools work from the user's next message.\n`;
     // Load Project Memory Bank
     try {
-        const memory = await MemoryManager.loadMemory();
+        const memory = MemoryManager.enabled ? memoryForPrompt(await MemoryManager.loadMemory()).text : '';
         if (memory.trim()) {
             prompt += `\n--- Project Knowledge & Memory Bank (.devx/memory.md) ---\n${memory}\n-------------------------------------------------------\n`;
         }
     }
     catch { }
+    // The plan the user approved (kept in the project, recent only): the work follows it.
+    try {
+        const plan = planMode ? '' : loadPlanForPrompt(process.cwd());
+        if (plan) {
+            prompt += `\n--- Approved plan (.devx/plan.md) ---\nFollow it for the task it was made for; if the user now asks for something else, ignore it.\n${plan}\n-------------------------------------\n`;
+        }
+    }
+    catch { }
     let currentDir = process.cwd();
     try {
         while (true) {

package/dist/providers/anthropic.js

@@ -0,0 +1,517 @@
+import { UsageTracker } from '../core/usage.js';
+import { priceUsage } from '../core/prices.js';
+import { ToolGuard } from './toolguard.js';
+import { NOT_ABOUT_REASONING, PARAMETER_REJECTED, errorMessageOf, imageNotSentText, parseToolArguments, readSseData, toolTargetHint } from './shared.js';
+/**
+ * Speaks the native Anthropic Messages API: `POST {origin}/v1/messages`.
+ *
+ * What differs from the OpenAI format (see openai.ts):
+ *   - the key goes into `x-api-key` and the version into `anthropic-version`
+ *   - the system prompt is a top-level field, `max_tokens` is required
+ *   - content is a list of typed blocks: text, tool_use, tool_result, thinking
+ *   - reasoning blocks carry a signature and are sent back unchanged with the next request
+ *   - the stream has typed events (message_start, content_block_delta, ...)
+ *   - usage separates cached input from the rest
+ */
+const API_VERSION = '2023-06-01';
+const DEFAULT_MAX_TOKENS = 16000;
+// Fields the extra parameters may never overwrite.
+const PROTECTED_FIELDS = new Set(['model', 'messages', 'stream', 'tools', 'system']);
+const num = (v) => (typeof v === 'number' && Number.isFinite(v) && v >= 0 ? v : 0);
+/** "https://host/v1/" and "https://host" both mean the same endpoint root. */
+export function anthropicRoot(baseUrl) {
+    return baseUrl.replace(/\/+$/, '').replace(/\/v1$/, '');
+}
+function splitDataUrl(dataUrl) {
+    const m = /^data:([^;,]+);base64,(.+)$/s.exec(dataUrl);
+    return m ? { mediaType: m[1], data: m[2] } : null;
+}
+/** Converts devx messages to the Anthropic shape. */
+export function toAnthropicMessages(messages, options = {}) {
+    const systemParts = [];
+    const out = [];
+    let lastImageIdx = -1;
+    messages.forEach((m, i) => {
+        if (m.images && m.images.length > 0)
+            lastImageIdx = i;
+    });
+    const push = (role, blocks) => {
+        if (blocks.length === 0)
+            return;
+        const last = out[out.length - 1];
+        // Two messages of one role in a row are one message for this API.
+        if (last && last.role === role)
+            last.content.push(...blocks);
+        else
+            out.push({ role, content: blocks });
+    };
+    messages.forEach((m, idx) => {
+        if (m.role === 'system') {
+            if (m.content)
+                systemParts.push(m.content);
+            return;
+        }
+        if (m.role === 'tool') {
+            push('user', [{ type: 'tool_result', tool_use_id: m.tool_call_id, content: m.content || '(empty)' }]);
+            return;
+        }
+        if (m.role === 'assistant') {
+            const blocks = [];
+            if (options.thinking !== false) {
+                for (const t of m.thinking_blocks ?? [])
+                    blocks.push({ ...t });
+            }
+            if (m.content)
+                blocks.push({ type: 'text', text: m.content });
+            for (const call of m.tool_calls ?? []) {
+                blocks.push({ type: 'tool_use', id: call.id, name: call.name, input: call.arguments ?? {} });
+            }
+            push('assistant', blocks.length > 0 ? blocks : [{ type: 'text', text: '(no content)' }]);
+            return;
+        }
+        const blocks = [];
+        let text = m.content || '';
+        if (m.images && m.images.length > 0) {
+            if (options.images === false) {
+                const note = imageNotSentText(m.images.map((img) => img.path));
+                text = text ? `${text}\n${note}` : note;
+            }
+            else if (idx === lastImageIdx) {
+                for (const img of m.images) {
+                    const parts = splitDataUrl(img.dataUrl);
+                    if (parts)
+                        blocks.push({ type: 'image', source: { type: 'base64', media_type: parts.mediaType, data: parts.data } });
+                }
+            }
+            else {
+                const refs = m.images.map((img) => `[Attached Image: ${img.path}]`).join(' ');
+                text = text ? `${text}\n${refs}` : refs;
+            }
+        }
+        if (text || blocks.length === 0)
+            blocks.push({ type: 'text', text: text || '(empty)' });
+        push('user', blocks);
+    });
+    if (options.cache && out.length > 0) {
+        // One breakpoint at the end of the conversation: the whole prefix is read from the cache next time.
+        const last = out[out.length - 1];
+        const tail = last.content[last.content.length - 1];
+        if (tail && tail.type !== 'thinking' && tail.type !== 'redacted_thinking')
+            tail.cache_control = { type: 'ephemeral' };
+    }
+    return { system: systemParts.join('\n\n'), messages: out };
+}
+export class AnthropicProvider {
+    baseUrl;
+    apiKey;
+    model;
+    extraBody;
+    options;
+    id = 'anthropic-messages';
+    extrasRejected = false;
+    cacheRejected = false;
+    thinkingBlocksRejected = false;
+    maxTokensCap = null;
+    notices = [];
+    imageNoticeShown = false;
+    constructor(baseUrl, apiKey, model, 
+    /** Extra request parameters, e.g. the reasoning setting from /effort. */
+    extraBody, options = {}) {
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+        this.model = model;
+        this.extraBody = extraBody;
+        this.options = options;
+    }
+    drainNotices() {
+        return this.notices.splice(0);
+    }
+    priceContext() {
+        return { ...this.options.price, model: this.model, baseUrl: this.baseUrl };
+    }
+    toolGuard = new ToolGuard();
+    hasActiveExtras() {
+        return !this.extrasRejected && !!this.extraBody && Object.keys(this.extraBody).length > 0;
+    }
+    buildPayload(request, stream, probe = false) {
+        const converted = toAnthropicMessages(request.messages, { cache: !this.cacheRejected, thinking: !this.thinkingBlocksRejected, images: this.options.images });
+        if (this.options.images === false && !this.imageNoticeShown && request.messages.some((m) => m.images?.length)) {
+            this.imageNoticeShown = true;
+            this.notices.push(`${this.model} cannot read images, so the image was not sent. Switch to a model with vision (/model).`);
+        }
+        const payload = {
+            model: this.model,
+            max_tokens: this.maxTokensCap ?? DEFAULT_MAX_TOKENS,
+            stream,
+            messages: converted.messages,
+        };
+        if (converted.system) {
+            payload.system = this.cacheRejected
+                ? converted.system
+                : [{ type: 'text', text: converted.system, cache_control: { type: 'ephemeral' } }];
+        }
+        // Tools the gateway refused are left out.
+        const tools = this.toolGuard.apply(request.tools);
+        if (tools && tools.length > 0) {
+            payload.tools = tools.map((t) => ({ name: t.name, description: t.description, input_schema: t.parameters }));
+            if (!this.cacheRejected)
+                payload.tools[payload.tools.length - 1].cache_control = { type: 'ephemeral' };
+        }
+        // A probe (to find out which tool is refused) costs next to nothing and does not carry the reasoning setting.
+        if (probe) {
+            payload.max_tokens = 1;
+            payload.stream = false;
+            return payload;
+        }
+        if (this.hasActiveExtras()) {
+            for (const [key, value] of Object.entries(this.extraBody)) {
+                if (PROTECTED_FIELDS.has(key))
+                    continue;
+                // `reasoning_effort` / `reasoning` are OpenAI-style: the Anthropic API refuses them as unknown fields.
+                if (key === 'reasoning_effort' || key === 'reasoning')
+                    continue;
+                // The cap learned from an error must not be undone by the reasoning setting.
+                if (key === 'max_tokens' && this.maxTokensCap !== null)
+                    continue;
+                payload[key] = value;
+            }
+        }
+        return payload;
+    }
+    headers() {
+        const headers = {
+            'Content-Type': 'application/json',
+            'anthropic-version': API_VERSION,
+        };
+        if (this.apiKey) {
+            headers['x-api-key'] = this.apiKey;
+            // Gateways in front of the API often read the key from the standard header instead.
+            let host = '';
+            try {
+                host = new URL(this.baseUrl).hostname.toLowerCase();
+            }
+            catch { }
+            if (host !== 'api.anthropic.com')
+                headers['Authorization'] = `Bearer ${this.apiKey}`;
+        }
+        return headers;
+    }
+    /**
+     * Posts the request. A 400 that complains about something devx added on its own (the
+     * reasoning setting, cache markers, signed reasoning blocks, a too large max_tokens) is
+     * repeated once without it, so an unusual gateway never makes the session unusable.
+     */
+    async send(request, stream) {
+        const url = `${anthropicRoot(this.baseUrl)}/v1/messages`;
+        const post = () => {
+            const bodyStr = JSON.stringify(this.buildPayload(request, stream));
+            UsageTracker.getInstance().recordRequest(Buffer.byteLength(bodyStr, 'utf8'));
+            return fetch(url, { method: 'POST', headers: this.headers(), body: bodyStr, signal: request.signal });
+        };
+        let res = await post();
+        let genericTry = false;
+        let toolsChecked = false;
+        const probeWith = async (tools) => {
+            const body = this.buildPayload({ ...request, tools: tools.length > 0 ? tools : undefined }, false, true);
+            const r = await fetch(url, { method: 'POST', headers: this.headers(), body: JSON.stringify(body), signal: request.signal });
+            await r.text().catch(() => '');
+            return r.ok;
+        };
+        for (let attempt = 0; attempt < 4 && !res.ok && (res.status === 400 || res.status === 422); attempt++) {
+            const text = await res.clone().text().catch(() => '');
+            const reason = errorMessageOf(text).replace(/\s+/g, ' ').slice(0, 110);
+            const cap = /max_tokens/i.test(text) ? this.capFromError(text) : null;
+            if (cap !== null) {
+                this.maxTokensCap = cap;
+            }
+            else if (/signature|redacted_thinking|thinking block/i.test(text) && !this.thinkingBlocksRejected) {
+                this.thinkingBlocksRejected = true;
+                this.notices.push(`The endpoint refused the saved reasoning blocks (${reason}). Continuing without them.`);
+            }
+            else if (/cache_control|cache control/i.test(text) && !this.cacheRejected) {
+                this.cacheRejected = true;
+            }
+            else if (this.hasActiveExtras() && PARAMETER_REJECTED.test(text)) {
+                this.extrasRejected = true;
+                this.notices.push(`The endpoint rejected the reasoning setting (${reason}). Continuing without it. /effort auto stops sending it for good.`);
+            }
+            else if (!toolsChecked && request.tools && request.tools.length > 0 && !NOT_ABOUT_REASONING.test(errorMessageOf(text))) {
+                // Refused, and it works without tools: a tool definition is what the gateway does not like.
+                toolsChecked = true;
+                const repair = await this.toolGuard.repair(this.toolGuard.apply(request.tools), probeWith);
+                if (repair.notice)
+                    this.notices.push(repair.notice);
+                if (!repair.changed) {
+                    if (this.hasActiveExtras() && !genericTry) {
+                        genericTry = true;
+                        this.extrasRejected = true;
+                    }
+                    else {
+                        break;
+                    }
+                }
+            }
+            else if (this.hasActiveExtras() && !genericTry && !NOT_ABOUT_REASONING.test(errorMessageOf(text))) {
+                // The refusal names nothing ("the model rejected this conversation or its parameters"). The reasoning
+                // setting is what devx added on its own, so it is tried without it once.
+                genericTry = true;
+                this.extrasRejected = true;
+            }
+            else {
+                break;
+            }
+            res = await post();
+        }
+        if (genericTry) {
+            if (res.ok) {
+                this.notices.push('The endpoint refused the request while a reasoning setting was sent; without it the request works. Continuing without it. /effort auto stops sending it for good.');
+            }
+            else {
+                this.extrasRejected = false; // it was not the setting: the real error is shown
+            }
+        }
+        return res;
+    }
+    /** "max_tokens: 16000 > 8192, which is the maximum allowed" -> 8192 */
+    capFromError(text) {
+        const current = this.maxTokensCap ?? DEFAULT_MAX_TOKENS;
+        const numbers = (errorMessageOf(text).match(/\d{3,7}/g) ?? []).map(Number).filter((n) => n >= 256 && n < current);
+        if (numbers.length === 0)
+            return null;
+        return Math.max(...numbers);
+    }
+    async failure(res) {
+        const text = await res.text();
+        UsageTracker.getInstance().recordResponseChunk(Buffer.byteLength(text, 'utf8'));
+        const err = new Error(`Provider HTTP Error ${res.status}: ${errorMessageOf(text)}`);
+        err.status = res.status;
+        throw err;
+    }
+    usageOf(raw, fallback) {
+        const guessed = !raw || (raw.input + raw.cacheRead + raw.cacheWrite + raw.output === 0);
+        const base = raw ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+        // Anthropic reports the cached tokens apart from input_tokens; devx counts them all as prompt.
+        const promptTokens = base.input + base.cacheRead + base.cacheWrite || (guessed ? fallback?.prompt ?? 0 : 0);
+        const completionTokens = base.output || (guessed ? fallback?.completion ?? 0 : 0);
+        const usage = { promptTokens, completionTokens, totalTokens: promptTokens + completionTokens };
+        if (base.cacheRead)
+            usage.cacheReadTokens = base.cacheRead;
+        if (base.cacheWrite)
+            usage.cacheWriteTokens = base.cacheWrite;
+        if (guessed && fallback)
+            usage.tokensEstimated = true;
+        const priced = priceUsage(this.priceContext(), usage);
+        if (priced.cost !== undefined) {
+            usage.cost = priced.cost;
+            usage.costSource = guessed && fallback && priced.costSource !== 'free' ? 'estimated' : priced.costSource;
+        }
+        UsageTracker.getInstance().recordUsage(usage);
+        return usage;
+    }
+    async chat(request) {
+        const res = await this.send(request, false);
+        if (!res.ok)
+            await this.failure(res);
+        const raw = await res.text();
+        UsageTracker.getInstance().recordResponseChunk(Buffer.byteLength(raw, 'utf8'));
+        let data;
+        try {
+            data = JSON.parse(raw);
+        }
+        catch {
+            throw new Error('Invalid JSON response from provider');
+        }
+        if (data.type === 'error' || data.error) {
+            throw new Error(`Provider Error: ${data.error?.message || JSON.stringify(data.error)}`);
+        }
+        let content = '';
+        const toolCalls = [];
+        const thinkingBlocks = [];
+        for (const block of Array.isArray(data.content) ? data.content : []) {
+            if (block.type === 'text')
+                content += block.text || '';
+            else if (block.type === 'thinking')
+                thinkingBlocks.push({ type: 'thinking', thinking: block.thinking || '', signature: block.signature || '' });
+            else if (block.type === 'redacted_thinking')
+                thinkingBlocks.push({ type: 'redacted_thinking', data: block.data || '' });
+            else if (block.type === 'tool_use') {
+                toolCalls.push({
+                    id: block.id || `toolu_${Math.random().toString(36).slice(2, 9)}`,
+                    name: block.name,
+                    arguments: block.input && typeof block.input === 'object' ? block.input : {},
+                });
+            }
+        }
+        // A reply cut off by the token limit while a tool call was being written has no usable call.
+        if (data.stop_reason === 'max_tokens' && toolCalls.length > 0) {
+            for (const call of toolCalls) {
+                if (Object.keys(call.arguments).length === 0)
+                    call.argsError = parseToolArguments('{').error;
+            }
+        }
+        const u = data.usage;
+        const usage = u
+            ? this.usageOf({
+                input: num(u.input_tokens), output: num(u.output_tokens),
+                cacheRead: num(u.cache_read_input_tokens), cacheWrite: num(u.cache_creation_input_tokens),
+            })
+            : undefined;
+        return {
+            content: content || null,
+            toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+            thinkingBlocks: thinkingBlocks.length > 0 ? thinkingBlocks : undefined,
+            usage,
+        };
+    }
+    async *chatStream(request) {
+        const res = await this.send(request, true);
+        if (!res.ok)
+            await this.failure(res);
+        const reader = res.body?.getReader();
+        if (!reader) {
+            const fallback = await this.chat(request);
+            yield { type: 'done', response: fallback };
+            return fallback;
+        }
+        if (request.signal) {
+            request.signal.addEventListener('abort', () => {
+                try {
+                    reader.cancel().catch(() => { });
+                }
+                catch { }
+            });
+        }
+        let content = '';
+        let reasoningChars = 0;
+        const blocks = new Map();
+        const tally = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+        let sawUsage = false;
+        let stopReason = '';
+        const readUsage = (u) => {
+            if (!u || typeof u !== 'object')
+                return;
+            sawUsage = true;
+            // Later events repeat or refine the numbers; a missing field must not erase an earlier value.
+            if (u.input_tokens !== undefined)
+                tally.input = num(u.input_tokens);
+            if (u.output_tokens !== undefined)
+                tally.output = num(u.output_tokens);
+            if (u.cache_read_input_tokens !== undefined)
+                tally.cacheRead = num(u.cache_read_input_tokens);
+            if (u.cache_creation_input_tokens !== undefined)
+                tally.cacheWrite = num(u.cache_creation_input_tokens);
+        };
+        try {
+            for await (const payload of readSseData(reader, request.signal, (n) => UsageTracker.getInstance().recordResponseChunk(n))) {
+                if (payload === '[DONE]')
+                    continue;
+                let event;
+                try {
+                    event = JSON.parse(payload);
+                }
+                catch {
+                    continue;
+                }
+                switch (event.type) {
+                    case 'error':
+                        throw new Error(`Provider Stream Error: ${event.error?.message || JSON.stringify(event.error)}`);
+                    case 'message_start':
+                        readUsage(event.message?.usage);
+                        break;
+                    case 'content_block_start': {
+                        const b = event.content_block || {};
+                        const kind = b.type === 'tool_use' ? 'tool' : b.type === 'thinking' ? 'thinking' : b.type === 'redacted_thinking' ? 'redacted' : 'text';
+                        blocks.set(event.index, {
+                            kind,
+                            text: kind === 'redacted' ? '' : b.text || b.thinking || '',
+                            signature: b.signature || '',
+                            id: b.id || '',
+                            name: b.name || '',
+                            json: kind === 'redacted' ? String(b.data || '') : '',
+                        });
+                        if (kind === 'tool')
+                            yield { type: 'tool_generating', name: b.name || 'tool', bytes: 0 };
+                        break;
+                    }
+                    case 'content_block_delta': {
+                        const block = blocks.get(event.index);
+                        const d = event.delta || {};
+                        if (!block)
+                            break;
+                        if (d.type === 'text_delta' && d.text) {
+                            block.text += d.text;
+                            content += d.text;
+                            yield { type: 'content_delta', delta: d.text };
+                        }
+                        else if (d.type === 'thinking_delta' && d.thinking) {
+                            block.text += d.thinking;
+                            reasoningChars += d.thinking.length;
+                            yield { type: 'reasoning_delta', delta: d.thinking };
+                        }
+                        else if (d.type === 'signature_delta' && d.signature) {
+                            block.signature += d.signature;
+                        }
+                        else if (d.type === 'input_json_delta' && typeof d.partial_json === 'string') {
+                            block.json += d.partial_json;
+                            yield { type: 'tool_generating', name: block.name || 'tool', bytes: block.json.length, targetHint: toolTargetHint(block.json) };
+                        }
+                        break;
+                    }
+                    case 'message_delta':
+                        readUsage(event.usage);
+                        if (event.delta?.stop_reason)
+                            stopReason = event.delta.stop_reason;
+                        break;
+                    default:
+                        break; // ping, content_block_stop, message_stop
+                }
+            }
+        }
+        finally {
+            try {
+                reader.releaseLock();
+            }
+            catch { }
+        }
+        const toolCalls = [];
+        const thinkingBlocks = [];
+        for (const index of [...blocks.keys()].sort((a, b) => a - b)) {
+            const b = blocks.get(index);
+            if (b.kind === 'thinking') {
+                // A reasoning block without a signature cannot be sent back; it would only make the next request fail.
+                if (b.signature)
+                    thinkingBlocks.push({ type: 'thinking', thinking: b.text, signature: b.signature });
+            }
+            else if (b.kind === 'redacted') {
+                thinkingBlocks.push({ type: 'redacted_thinking', data: b.json });
+            }
+            else if (b.kind === 'tool') {
+                const parsed = parseToolArguments(b.json);
+                toolCalls.push({
+                    id: b.id || `toolu_${Math.random().toString(36).slice(2, 9)}`,
+                    name: b.name,
+                    arguments: parsed.args,
+                    ...(parsed.error ? { argsError: parsed.error } : {}),
+                });
+            }
+        }
+        if (!content && reasoningChars === 0 && toolCalls.length === 0) {
+            throw new Error(`Provider returned empty response (0 tokens generated). Please check your model '${this.model}', balance, or API key.`);
+        }
+        if (stopReason === 'max_tokens' && toolCalls.length === 0 && !content && reasoningChars > 0) {
+            this.notices.push('The reply was cut off by the output limit while the model was still thinking. Lower /effort or ask again.');
+        }
+        const usage = this.usageOf(sawUsage ? tally : null, {
+            prompt: Math.ceil(JSON.stringify(request.messages).length / 3.5),
+            completion: Math.ceil((content.length + reasoningChars) / 3.5),
+        });
+        const response = {
+            content: content || null,
+            toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+            thinkingBlocks: thinkingBlocks.length > 0 ? thinkingBlocks : undefined,
+            usage,
+        };
+        yield { type: 'done', response };
+        return response;
+    }
+}

package/dist/providers/index.js

@@ -1,7 +1,24 @@
+import { effectiveReasoning } from '../core/reasoning.js';
+import { resolveFormat } from '../core/formats.js';
+import { modelAcceptsImages } from '../core/vision.js';
 import { OpenAIProvider } from './openai.js';
+import { AnthropicProvider } from './anthropic.js';
 export function createProvider(config) {
     const baseUrl = config.baseUrl || 'https://api.openai.com/v1';
     const apiKey = config.apiKey || process.env.OPENAI_API_KEY || '';
     const model = config.model || 'gpt-4o-mini';
-    return new OpenAIProvider(baseUrl, apiKey, model);
+    // OpenAI or Anthropic wire format: by the base URL, or by what the gateway offers for this model.
+    const format = resolveFormat({ baseUrl, model, apiFormat: config.apiFormat });
+    // The reasoning level chosen with /effort, translated for this model and this API.
+    const { params } = effectiveReasoning({ ...config, model, baseUrl });
+    // Images are sent unless the catalogue says the model takes text only.
+    const options = { price: { provider: config.provider, prices: config.prices }, images: modelAcceptsImages(model) !== false };
+    if (format === 'anthropic') {
+        return new AnthropicProvider(baseUrl, apiKey || process.env.ANTHROPIC_API_KEY || '', model, params ?? undefined, options);
+    }
+    return new OpenAIProvider(baseUrl, apiKey, model, params ?? undefined, options);
+}
+/** Which format the provider for this config speaks (for the status line and notices). */
+export function providerFormat(config) {
+    return resolveFormat({ baseUrl: config.baseUrl || 'https://api.openai.com/v1', model: config.model || 'gpt-4o-mini', apiFormat: config.apiFormat });
 }