termux-dev 1.8.1 → 1.9.0

package/dist/core/loop.js

@@ -32,6 +32,17 @@ export function getActionDescription(toolName, args) {
     if (t === 'bash' || t === 'execute_command' || t === 'run_command' || t === 'exec') {
         return `→ Run: ${args.command || args.cmd || ''}`;
     }
+    if (t === 'background') {
+        const id = args.id ? ` ${args.id}` : '';
+        switch (args.action) {
+            case 'start': return `→ Background: ${args.label ? `${args.label} · ` : ''}${args.command || ''}`;
+            case 'list': return `→ Background: list tasks`;
+            case 'output': return `→ Background: output${id}`;
+            case 'wait': return `→ Background: wait${id}${args.pattern ? ` for /${args.pattern}/` : ''}`;
+            case 'stop': return `→ Background: stop${id}`;
+            default: return `→ Background`;
+        }
+    }
     if (t === 'todo_list' || t === 'update_todos') {
         return `→ Update Plan & Tasks`;
     }
@@ -50,6 +61,15 @@ export function getActionDescription(toolName, args) {
     return `→ Executing ${toolName}...`;
 }
 const CONTEXT_LENGTH_ERROR = /context[_ ]length|maximum context|context window|too many tokens|prompt is too long|reduce the length|input is too long|exceeds? the (?:model|maximum|max)/i;
+/**
+ * A request that failed in a way that usually still costs money: the connection broke or timed out
+ * after the request had gone out (no HTTP status), or a gateway gave up waiting for a slow model
+ * (504, 524) that went on working. Rejections (400, 401, 429, ...) are not billed.
+ */
+function probablyBilled(err) {
+    const status = err?.status ?? err?.statusCode;
+    return status === undefined || status === 0 || status === 504 || status === 524;
+}
 function isContextLengthError(err) {
     const status = err?.status;
     if (status !== undefined && status !== 400 && status !== 413 && status !== 422)
@@ -83,6 +103,12 @@ export class Agent {
                 this.history.addMessage(message);
                 yield { type: 'user_message', content: message.content };
             }
+            // A background task ended or printed what was asked for: the model learns it before it decides.
+            const news = hooks?.takeNotes?.();
+            if (news) {
+                this.history.addMessage({ role: 'user', content: news });
+                yield { type: 'background_note', content: news };
+            }
             const toolDefinitions = Array.from(this.tools.values()).map((t) => t.definition);
             // Tool schemas are sent with every request and count against the context window.
             const schemaTokens = toolSchemaTokens(toolDefinitions);
@@ -103,21 +129,32 @@ export class Agent {
             let attempt = 0;
             let contextRetries = 0;
             const maxRetries = 4;
+            // A request that goes out and gets no answer (cancelled, connection lost, gateway timeout) is
+            // usually billed all the same, and a retry sends the whole conversation again. Such requests
+            // are counted as an estimate instead of being left out of the cost.
+            let receivedChars = 0;
+            const lostUsage = () => this.provider.lostRequestUsage?.(this.history.getTotalTokens() + schemaTokens, Math.ceil(receivedChars * 0.33));
             while (true) {
                 if (signal?.aborted)
                     return;
+                receivedChars = 0;
                 try {
                     if (this.provider.chatStream) {
                         let receivedAnyChunk = false;
                         for await (const chunk of this.provider.chatStream(request)) {
                             if (signal?.aborted) {
+                                const lost = lostUsage();
+                                if (lost)
+                                    yield { type: 'usage', usage: lost };
                                 return;
                             }
                             receivedAnyChunk = true;
                             if (chunk.type === 'reasoning_delta') {
+                                receivedChars += chunk.delta.length;
                                 yield { type: 'reasoning_delta', delta: chunk.delta };
                             }
                             else if (chunk.type === 'content_delta') {
+                                receivedChars += chunk.delta.length;
                                 yield { type: 'text_delta', delta: chunk.delta };
                             }
                             else if (chunk.type === 'tool_generating') {
@@ -142,6 +179,9 @@ export class Agent {
                 }
                 catch (err) {
                     if (signal?.aborted || err.name === 'AbortError' || err.message?.includes('aborted')) {
+                        const lost = lostUsage();
+                        if (lost)
+                            yield { type: 'usage', usage: lost };
                         return;
                     }
                     // The provider says the prompt is too long (our estimate was too optimistic):
@@ -155,6 +195,11 @@ export class Agent {
                         continue;
                     }
                     const isNetwork = isNetworkOrRetryableError(err);
+                    if (isNetwork && probablyBilled(err)) {
+                        const lost = lostUsage();
+                        if (lost)
+                            yield { type: 'usage', usage: lost };
+                    }
                     if (isNetwork && attempt < maxRetries) {
                         attempt++;
                         const delayMs = Math.min(1500 * Math.pow(1.5, attempt - 1), 8000);
@@ -207,7 +252,7 @@ export class Agent {
             }
             if (!response.toolCalls || response.toolCalls.length === 0) {
                 // The user wrote something while the model was finishing: answer it instead of stopping.
-                if (hooks?.hasPending?.()) {
+                if (hooks?.hasPending?.() || hooks?.hasNotes?.()) {
                     iterations++;
                     continue;
                 }
@@ -223,6 +268,8 @@ export class Agent {
                     if (signal?.aborted)
                         return;
                     let result = '';
+                    // Pictures a tool wants the model to see (read_file on an image) travel with its result.
+                    const pictures = [];
                     const tool = this.tools.get(call.name);
                     if (!tool) {
                         result = `Error: Tool '${call.name}' not found.`;
@@ -246,7 +293,7 @@ export class Agent {
                                 if (signal?.aborted)
                                     return;
                                 result = allowed
-                                    ? await tool.execute(call.arguments, this.config, { signal })
+                                    ? await tool.execute(call.arguments, this.config, { signal, attachImage: (image) => pictures.push(image) })
                                     : 'Action denied by user.';
                                 if (allowed) {
                                     const post = await runHooks(this.config.hooks, 'PostToolUse', tool.name, call.arguments, result);
@@ -269,6 +316,7 @@ export class Agent {
                         content: result,
                         tool_call_id: call.id,
                         name: call.name,
+                        ...(pictures.length > 0 ? { images: pictures } : {}),
                     });
                     executedToolCallIds.add(call.id);
                     yield { type: 'tool_end', id: call.id, name: call.name, result };

package/dist/core/prices.js

@@ -3,7 +3,7 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 import { NATIVE_PROVIDERS, devxDir, normalizeModelKey, readJsonFile } from './catalog-util.js';
 import { ensureSecureDir } from './secure-file.js';
-import { computeCost, isFreeModel, reportedCost, } from './cost.js';
+import { costParts, isFreeModel, reportedCost, scaleParts, } from './cost.js';
 /**
  * Prices of models: where they come from and how a request is priced.
  *
@@ -240,10 +240,14 @@ export function priceUsage(ctx, counts, rawUsage) {
     const tokens = (counts.promptTokens || 0) + (counts.completionTokens || 0);
     if (reported !== undefined) {
         const suspicious = reported === 0 && tokens > 0 && !!info && info.source !== 'free' && info.rates.input + info.rates.output > 0;
-        if (!suspicious)
-            return { cost: reported, costSource: reported === 0 && info?.source === 'free' ? 'free' : 'reported' };
+        if (!suspicious) {
+            // The provider gave only the total: split it in the proportions of the known rates.
+            const parts = info ? scaleParts(costParts(info.rates, counts), reported) : undefined;
+            return { cost: reported, costSource: reported === 0 && info?.source === 'free' ? 'free' : 'reported', parts };
+        }
     }
     if (!info)
         return {};
-    return { cost: computeCost(info.rates, counts), costSource: info.source };
+    const parts = costParts(info.rates, counts);
+    return { cost: parts.input + parts.cacheRead + parts.cacheWrite + parts.output, costSource: info.source, parts };
 }

package/dist/core/session-media.js

@@ -0,0 +1,115 @@
+import crypto from 'crypto';
+import fs from 'fs/promises';
+import path from 'path';
+import { ensureSecureDir } from './secure-file.js';
+/**
+ * Pictures of a saved chat live in files next to it, not inside its JSON. A picture is a data URL
+ * of up to several megabytes; written into the chat file it made every save (after every turn)
+ * rewrite all of them, and the list of chats (/resume) had to read and parse every one.
+ *
+ * On disk a message carries `{ path, file }`; the bytes are in `<chat id>.images/<file>`, named by
+ * their hash, so the same picture is stored once however often it is saved.
+ */
+const EXT_BY_MIME = {
+    'image/png': 'png',
+    'image/jpeg': 'jpg',
+    'image/webp': 'webp',
+    'image/gif': 'gif',
+};
+const MIME_BY_EXT = Object.fromEntries(Object.entries(EXT_BY_MIME).map(([mime, ext]) => [ext, mime]));
+export const imagesDirFor = (sessionsDir, sessionId) => path.join(sessionsDir, `${sessionId}.images`);
+const DATA_URL = /^data:([^;,]+);base64,(.*)$/s;
+/**
+ * The messages as they are written to disk: pictures replaced by the name of their file, the
+ * files written. Returns the names in use, so the others can be removed. The messages passed in
+ * are not changed.
+ */
+export async function externalizeImages(messages, dir, index = new Map()) {
+    const used = new Set();
+    let dirReady = false;
+    const store = async (image) => {
+        const match = DATA_URL.exec(image.dataUrl ?? '');
+        const ext = match ? EXT_BY_MIME[match[1]] : undefined;
+        if (!match || !ext)
+            return image; // not something we can store: keep it as it is
+        let file = index.get(image.dataUrl);
+        if (!file) {
+            file = `${crypto.createHash('sha256').update(image.dataUrl).digest('hex').slice(0, 32)}.${ext}`;
+            index.set(image.dataUrl, file);
+        }
+        used.add(file);
+        const target = path.join(dir, file);
+        try {
+            await fs.access(target);
+        }
+        catch {
+            if (!dirReady) {
+                await ensureSecureDir(dir);
+                dirReady = true;
+            }
+            // Written aside and renamed: a crash must not leave half a picture under the real name.
+            const part = `${target}.part`;
+            await fs.writeFile(part, Buffer.from(match[2], 'base64'), { mode: 0o600 });
+            await fs.rename(part, target);
+        }
+        return { path: image.path, dataUrl: '', file };
+    };
+    const out = [];
+    for (const message of messages) {
+        if (!message.images || message.images.length === 0) {
+            out.push(message);
+            continue;
+        }
+        const images = [];
+        for (const image of message.images)
+            images.push(await store(image));
+        out.push({ ...message, images });
+    }
+    return { messages: out, used };
+}
+/**
+ * The messages of a loaded chat with their pictures read back from the files. A picture whose
+ * file is gone is dropped (the text of the message still says what it was); a chat saved by an
+ * older devx, with the data inside, is left as it is.
+ */
+export async function internalizeImages(messages, dir) {
+    const out = [];
+    for (const message of messages) {
+        if (!message.images || message.images.length === 0) {
+            out.push(message);
+            continue;
+        }
+        const images = [];
+        for (const image of message.images) {
+            const file = image.file;
+            if (!file) {
+                if (image.dataUrl)
+                    images.push(image);
+                continue;
+            }
+            const mime = MIME_BY_EXT[path.extname(file).slice(1).toLowerCase()];
+            // A name from a file on disk must not lead out of the folder.
+            if (!mime || path.basename(file) !== file)
+                continue;
+            try {
+                const data = await fs.readFile(path.join(dir, file));
+                images.push({ path: image.path, dataUrl: `data:${mime};base64,${data.toString('base64')}` });
+            }
+            catch { }
+        }
+        const { images: _dropped, ...rest } = message;
+        out.push(images.length > 0 ? { ...rest, images } : rest);
+    }
+    return out;
+}
+/** Removes the picture files that no message uses any more (after a /rewind, for example). */
+export async function pruneImages(dir, used) {
+    let names;
+    try {
+        names = await fs.readdir(dir);
+    }
+    catch {
+        return;
+    }
+    await Promise.all(names.filter((n) => !used.has(n)).map((n) => fs.rm(path.join(dir, n), { force: true }).catch(() => { })));
+}

package/dist/core/session.js

@@ -3,9 +3,12 @@ import fsSync from 'fs';
 import path from 'path';
 import os from 'os';
 import { ensureSecureDir, writeSecureFile } from './secure-file.js';
+import { externalizeImages, imagesDirFor, internalizeImages, pruneImages } from './session-media.js';
 const SESSIONS_DIR = path.join(os.homedir(), '.devx', 'sessions');
 export class SessionManager {
     currentSession;
+    /** The files of the pictures already seen (see session-media.ts). */
+    media = new Map();
     constructor(model, planMode) {
         this.currentSession = this.createEmptySession(model, planMode);
     }
@@ -36,6 +39,7 @@ export class SessionManager {
     }
     startNewSession(model, planMode) {
         this.currentSession = this.createEmptySession(model, planMode);
+        this.media = new Map();
         return this.currentSession;
     }
     async save(messages, totalCost, model, planMode, costEstimated) {
@@ -61,8 +65,12 @@ export class SessionManager {
                 this.currentSession.title = title || 'Session';
             }
         }
+        // Pictures go into their own files; the chat file keeps only their names.
+        const imagesDir = imagesDirFor(SESSIONS_DIR, this.currentSession.id);
+        const stored = await externalizeImages(messages, imagesDir, this.media);
         const filePath = path.join(SESSIONS_DIR, `${this.currentSession.id}.json`);
-        await writeSecureFile(filePath, JSON.stringify(this.currentSession, null, 2));
+        await writeSecureFile(filePath, JSON.stringify({ ...this.currentSession, messages: stored.messages }, null, 2));
+        await pruneImages(imagesDir, stored.used);
     }
     static async listSessions() {
         if (!fsSync.existsSync(SESSIONS_DIR)) {
@@ -95,7 +103,9 @@ export class SessionManager {
             return null;
         try {
             const content = await fs.readFile(filePath, 'utf8');
-            return JSON.parse(content);
+            const session = JSON.parse(content);
+            session.messages = await internalizeImages(session.messages ?? [], imagesDirFor(SESSIONS_DIR, sessionId));
+            return session;
         }
         catch {
             return null;
@@ -104,6 +114,7 @@ export class SessionManager {
     static async deleteSession(sessionId) {
         const filePath = path.join(SESSIONS_DIR, `${sessionId}.json`);
         try {
+            await fs.rm(imagesDirFor(SESSIONS_DIR, sessionId), { recursive: true, force: true }).catch(() => { });
             if (fsSync.existsSync(filePath)) {
                 await fs.unlink(filePath);
                 return true;
@@ -128,6 +139,10 @@ export class SessionManager {
                 }
                 catch { }
             }
+            // The pictures of the chats, and those of chats whose file is already gone.
+            for (const name of files.filter(f => f.endsWith('.images'))) {
+                await fs.rm(path.join(SESSIONS_DIR, name), { recursive: true, force: true }).catch(() => { });
+            }
             return count;
         }
         catch {

package/dist/core/title.js

@@ -31,9 +31,15 @@ export function cleanTitle(raw) {
 export function provisionalTitle(firstUserMessage) {
     return cleanTitle(firstUserMessage.replace(/\s+/g, ' ').slice(0, 80));
 }
-/** Asks the model for the name. Never throws: on a failure or a timeout the answer is ''. */
+/**
+ * Asks the model for the name. Never throws: on a failure or a timeout the answer is ''. When the
+ * time is up the request is cut off, so a slow thinking model does not go on (and bill) for a
+ * title nobody waits for.
+ */
 export async function generateChatTitle(provider, firstUser, firstReply, timeoutMs = 20000) {
     const sample = `User: ${firstUser.slice(0, 600)}\n\nAssistant: ${firstReply.slice(0, 600)}`;
+    const controller = new AbortController();
+    let timer;
     try {
         const answer = await Promise.race([
             provider.chat({
@@ -41,14 +47,25 @@ export async function generateChatTitle(provider, firstUser, firstReply, timeout
                     { role: 'system', content: TITLE_SYSTEM_PROMPT },
                     { role: 'user', content: sample },
                 ],
+                signal: controller.signal,
+            }),
+            // Also for a provider that ignores the signal: the title is given up on when the time is up.
+            new Promise((_, reject) => {
+                timer = setTimeout(() => {
+                    controller.abort();
+                    reject(new Error('timeout'));
+                }, timeoutMs);
+                timer.unref?.();
             }),
-            new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), timeoutMs).unref?.()),
         ]);
         return cleanTitle(answer.content);
     }
     catch {
         return '';
     }
+    finally {
+        clearTimeout(timer);
+    }
 }
 // ───────────────────────── terminal window title ─────────────────────────
 /** The escape sequence that sets the title of the terminal window (OSC 0): `◈ Short title`. */

package/dist/core/types.js

@@ -1 +1 @@
-export const DEVX_VERSION = '1.8.1';
+export const DEVX_VERSION = '1.9.0';

package/dist/core/usage.js

@@ -14,6 +14,11 @@ export class UsageTracker {
     ledger = new CostLedger();
     cacheReadTokens = 0;
     cacheWriteTokens = 0;
+    uncachedTokens = 0;
+    parts = { input: 0, cacheRead: 0, cacheWrite: 0, output: 0 };
+    /** Priced requests that came without a split. */
+    unsplit = 0;
+    restored = 0;
     lastPromptTokens = 0;
     dataSaverLimitMB;
     warnedThreshold = false;
@@ -37,9 +42,22 @@ export class UsageTracker {
         this.ledger.reset();
         this.cacheReadTokens = 0;
         this.cacheWriteTokens = 0;
+        this.uncachedTokens = 0;
+        this.parts = { input: 0, cacheRead: 0, cacheWrite: 0, output: 0 };
+        this.unsplit = 0;
+        this.restored = 0;
         this.lastPromptTokens = 0;
         this.warnedThreshold = false;
     }
+    /**
+     * A saved chat was resumed: what it cost so far is the starting point of the total, so that
+     * /usage and the prompt frame show the same number. Counting starts from zero before this.
+     */
+    restoreCost(total, estimated = false) {
+        this.reset();
+        this.ledger.restore(total, estimated);
+        this.restored = Number.isFinite(total) && total > 0 ? total : 0;
+    }
     recordRequest(payloadBytes) {
         this.bytesSent += payloadBytes;
         this.requestsCount += 1;
@@ -48,15 +66,29 @@ export class UsageTracker {
         this.bytesReceived += chunkBytes;
     }
     /** Records the tokens of one request; an undefined cost means the price is not known. */
-    recordTokens(promptTokens, completionTokens, cost, costSource) {
+    recordTokens(promptTokens, completionTokens, cost, costSource, parts) {
         this.promptTokens += promptTokens;
         this.completionTokens += completionTokens;
         this.ledger.add({ cost, costSource });
+        if (typeof cost === 'number' && Number.isFinite(cost)) {
+            if (parts) {
+                this.parts.input += parts.input;
+                this.parts.cacheRead += parts.cacheRead;
+                this.parts.cacheWrite += parts.cacheWrite;
+                this.parts.output += parts.output;
+            }
+            else {
+                this.unsplit++;
+            }
+        }
     }
     recordUsage(usage) {
-        this.recordTokens(usage.promptTokens, usage.completionTokens, usage.cost, usage.costSource);
-        this.cacheReadTokens += usage.cacheReadTokens || 0;
-        this.cacheWriteTokens += usage.cacheWriteTokens || 0;
+        this.recordTokens(usage.promptTokens, usage.completionTokens, usage.cost, usage.costSource, usage.costParts);
+        const read = Math.min(usage.promptTokens, usage.cacheReadTokens || 0);
+        const written = Math.min(usage.promptTokens - read, usage.cacheWriteTokens || 0);
+        this.cacheReadTokens += read;
+        this.cacheWriteTokens += written;
+        this.uncachedTokens += Math.max(0, usage.promptTokens - read - written);
         if (!usage.tokensEstimated)
             this.lastPromptTokens = usage.promptTokens;
     }
@@ -72,6 +104,11 @@ export class UsageTracker {
             totalCost: this.ledger.total,
             costState: this.ledger.state(),
             cacheReadTokens: this.cacheReadTokens,
+            cacheWriteTokens: this.cacheWriteTokens,
+            uncachedTokens: this.uncachedTokens,
+            // The split covers only what was counted since launch: with a restored total it would not add up.
+            costParts: this.unsplit === 0 && this.restored === 0 && this.ledger.priced > 0 ? { ...this.parts } : undefined,
+            restoredCost: this.restored > 0 ? this.restored : undefined,
             lastPromptTokens: this.lastPromptTokens,
             dataSaverLimitMB: this.dataSaverLimitMB
         };

package/dist/permissions/guard.js

@@ -277,7 +277,7 @@ function hasComplexChainingOrRedirection(commandStr) {
         commandStr.includes('\r'));
 }
 // ───────────────────────── guard ─────────────────────────
-const SHELL_TOOLS = new Set(['bash', 'exec', 'run_command', 'execute_command']);
+const SHELL_TOOLS = new Set(['bash', 'background', 'exec', 'run_command', 'execute_command']);
 const READ_TOOLS = new Set(['read_file', 'view_file', 'read', 'list_dir', 'list_files', 'ls', 'search', 'grep_search', 'grep', 'diagnose_code']);
 const WRITE_TOOLS = new Set(['write_file', 'edit_file', 'make_dir', 'mkdir', 'create_file', 'write_to_file', 'patch']);
 function pathArg(args) {
@@ -328,6 +328,9 @@ export class CLIConsoleGuard {
         const t = (toolName || '').toLowerCase();
         const cmd = (args?.command || args?.cmd || '').trim();
         const target = pathArg(args);
+        // Extra: the agent does anything it likes, nothing is asked.
+        if (this.options.extra && this.autoApprove)
+            return false;
         // Critical safety net. These ask for confirmation even in YOLO mode.
         if (SHELL_TOOLS.has(t) && (isDangerousBashCommand(cmd) || shellTouchesSecrets(cmd)))
             return true;
@@ -409,6 +412,8 @@ export function buildPermissionRequest(toolName, args) {
             notes.push('looks destructive or runs downloaded code');
         else if (shellTouchesSecrets(cmd))
             notes.push('reads a credentials / secrets file: its content would reach the model');
+        if (t === 'background')
+            notes.push('keeps running in the background until it ends or you stop it');
         return { title: t === 'bash' ? 'bash' : toolName, danger, lines: cmd.split('\n'), notes };
     }
     if (t === 'mcp_manage') {

package/dist/prompts/builder.js

@@ -34,7 +34,8 @@ export async function buildSystemPrompt(planMode) {
         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 += `- 'bash' stops after 120 s and cuts long output: give a long job a timeout, and print only what you need (head, tail, grep).\n`;
+        prompt += `- Anything that keeps running (dev server, watcher, long test run or build) goes to the 'background' tool, not to 'bash': action 'start' returns at once and the work goes on while you continue. Set notify_on to a regex ('ready|listening|error|FAIL') to be told when such a line appears; you are always told when a task ends. Then do other work or finish your answer: do not poll. To wait for a line use action 'wait' with a pattern, to read output use 'output', to end it use 'stop'. The user sees the tasks under /tasks. Never start the same server twice: check 'list' first.\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)

package/dist/providers/anthropic.js

@@ -1,7 +1,7 @@
 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';
+import { DEFAULT_REQUEST_TIMEOUT_MS, NOT_ABOUT_REASONING, RequestWatchdog, PARAMETER_REJECTED, errorMessageOf, imageNotSentText, imagesToSend, parseToolArguments, readSseData, toolTargetHint } from './shared.js';
 /**
  * Speaks the native Anthropic Messages API: `POST {origin}/v1/messages`.
  *
@@ -30,11 +30,11 @@ function splitDataUrl(dataUrl) {
 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 send = imagesToSend(messages);
+    const imageBlock = (img) => {
+        const parts = splitDataUrl(img.dataUrl);
+        return parts ? { type: 'image', source: { type: 'base64', media_type: parts.mediaType, data: parts.data } } : null;
+    };
     const push = (role, blocks) => {
         if (blocks.length === 0)
             return;
@@ -52,7 +52,21 @@ export function toAnthropicMessages(messages, options = {}) {
             return;
         }
         if (m.role === 'tool') {
-            push('user', [{ type: 'tool_result', tool_use_id: m.tool_call_id, content: m.content || '(empty)' }]);
+            const text = m.content || '(empty)';
+            let content = text;
+            if (m.images && m.images.length > 0) {
+                if (options.images === false) {
+                    content = `${text}\n${imageNotSentText(m.images.map((img) => img.path))}`;
+                }
+                else if (send.has(idx)) {
+                    // This API takes pictures inside a tool result.
+                    content = [{ type: 'text', text }, ...m.images.map(imageBlock).filter((b) => !!b)];
+                }
+                else {
+                    content = `${text}\n${m.images.map((img) => `[Attached Image: ${img.path}]`).join(' ')}`;
+                }
+            }
+            push('user', [{ type: 'tool_result', tool_use_id: m.tool_call_id, content }]);
             return;
         }
         if (m.role === 'assistant') {
@@ -76,11 +90,11 @@ export function toAnthropicMessages(messages, options = {}) {
                 const note = imageNotSentText(m.images.map((img) => img.path));
                 text = text ? `${text}\n${note}` : note;
             }
-            else if (idx === lastImageIdx) {
+            else if (send.has(idx)) {
                 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 } });
+                    const block = imageBlock(img);
+                    if (block)
+                        blocks.push(block);
                 }
             }
             else {
@@ -287,6 +301,10 @@ export class AnthropicProvider {
         err.status = res.status;
         throw err;
     }
+    lostRequestUsage(promptTokens, completionTokens) {
+        // usageOf records the usage itself.
+        return this.usageOf(null, { prompt: promptTokens, completion: completionTokens });
+    }
     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 };
@@ -304,11 +322,44 @@ export class AnthropicProvider {
         if (priced.cost !== undefined) {
             usage.cost = priced.cost;
             usage.costSource = guessed && fallback && priced.costSource !== 'free' ? 'estimated' : priced.costSource;
+            if (priced.parts)
+                usage.costParts = priced.parts;
         }
         UsageTracker.getInstance().recordUsage(usage);
         return usage;
     }
+    get timeoutMs() {
+        return this.options.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+    }
     async chat(request) {
+        const watch = new RequestWatchdog(this.timeoutMs, request.signal);
+        try {
+            return await this.chatOnce({ ...request, signal: watch.signal });
+        }
+        catch (err) {
+            throw watch.timedOut ? watch.error() : err;
+        }
+        finally {
+            watch.stop();
+        }
+    }
+    async *chatStream(request) {
+        const watch = new RequestWatchdog(this.timeoutMs, request.signal);
+        try {
+            const response = yield* this.streamOnce({ ...request, signal: watch.signal }, watch);
+            // The time ran out and the stream was cut: what came so far is not an answer.
+            if (watch.timedOut)
+                throw watch.error();
+            return response;
+        }
+        catch (err) {
+            throw watch.timedOut ? watch.error() : err;
+        }
+        finally {
+            watch.stop();
+        }
+    }
+    async chatOnce(request) {
         const res = await this.send(request, false);
         if (!res.ok)
             await this.failure(res);
@@ -363,7 +414,7 @@ export class AnthropicProvider {
             usage,
         };
     }
-    async *chatStream(request) {
+    async *streamOnce(request, watch) {
         const res = await this.send(request, true);
         if (!res.ok)
             await this.failure(res);
@@ -402,7 +453,7 @@ export class AnthropicProvider {
                 tally.cacheWrite = num(u.cache_creation_input_tokens);
         };
         try {
-            for await (const payload of readSseData(reader, request.signal, (n) => UsageTracker.getInstance().recordResponseChunk(n))) {
+            for await (const payload of readSseData(reader, request.signal, (n) => { watch.touch(); UsageTracker.getInstance().recordResponseChunk(n); })) {
                 if (payload === '[DONE]')
                     continue;
                 let event;
@@ -473,6 +524,9 @@ export class AnthropicProvider {
             }
             catch { }
         }
+        // Cut off because it went silent: nothing here is an answer, and it must not be counted as one.
+        if (watch.timedOut)
+            throw watch.error();
         const toolCalls = [];
         const thinkingBlocks = [];
         for (const index of [...blocks.keys()].sort((a, b) => a - b)) {