termux-dev 1.8.2 → 1.9.0

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)) {

package/dist/providers/index.js

@@ -3,16 +3,29 @@ 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 LEVEL_ORDER = ['off', 'low', 'normal', 'high', 'xhigh', 'max'];
+export function createProvider(config, opts = {}) {
     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';
     // 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 });
+    const chosen = effectiveReasoning({ ...config, model, baseUrl });
+    let params = chosen.params;
+    if (opts.light && chosen.caps.supported) {
+        const lightest = LEVEL_ORDER.find((level) => chosen.caps.levels.includes(level));
+        if (lightest)
+            params = effectiveReasoning({ ...config, model, baseUrl, effortOverride: lightest }).params;
+    }
     // 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 };
+    const seconds = Number(config.requestTimeoutSeconds);
+    const options = {
+        price: { provider: config.provider, prices: config.prices },
+        images: modelAcceptsImages(model) !== false,
+        // 0 turns the limit off; anything that is not a number keeps the default.
+        timeoutMs: Number.isFinite(seconds) && seconds >= 0 && config.requestTimeoutSeconds !== undefined && config.requestTimeoutSeconds !== '' ? seconds * 1000 : undefined,
+    };
     if (format === 'anthropic') {
         return new AnthropicProvider(baseUrl, apiKey || process.env.ANTHROPIC_API_KEY || '', model, params ?? undefined, options);
     }

package/dist/providers/openai.js

@@ -1,6 +1,6 @@
 import { UsageTracker } from '../core/usage.js';
 import { ToolGuard } from './toolguard.js';
-import { NOT_ABOUT_REASONING, PARAMETER_REJECTED, errorMessageOf, imageNotSentText, openAiUsage, parseToolArguments, toolTargetHint } from './shared.js';
+import { DEFAULT_REQUEST_TIMEOUT_MS, NOT_ABOUT_REASONING, RequestWatchdog, PARAMETER_REJECTED, errorMessageOf, imageNotSentText, imagesToSend, openAiUsage, parseToolArguments, toolTargetHint } from './shared.js';
 export { parseToolArguments };
 // Fields the extra parameters may never overwrite.
 const PROTECTED_FIELDS = new Set(['model', 'messages', 'stream', 'tools', 'stream_options']);
@@ -97,29 +97,41 @@ export class OpenAIProvider {
         return retry;
     }
     buildPayload(request, stream, probe = false) {
-        const totalMsgs = request.messages.length;
-        let lastImageMsgIdx = -1;
-        for (let i = totalMsgs - 1; i >= 0; i--) {
-            if (request.messages[i].images && request.messages[i].images.length > 0) {
-                lastImageMsgIdx = i;
-                break;
-            }
-        }
-        const payload = {
-            model: this.model,
-            stream,
-            messages: request.messages.map((m, idx) => {
-                let content = m.content || "";
-                if (m.images && m.images.length > 0) {
-                    if (this.options.images === false) {
-                        const note = imageNotSentText(m.images.map(img => img.path));
-                        content = m.content ? `${m.content}\n${note}` : note;
-                        if (!this.imageNoticeShown) {
-                            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 send = imagesToSend(request.messages);
+        const messages = [];
+        // Pictures that tool results carry: this format only takes text in a tool message, so they
+        // follow the run of tool messages as one message of the user.
+        let toolPictures = [];
+        const flushToolPictures = () => {
+            if (toolPictures.length === 0)
+                return;
+            messages.push({
+                role: 'user',
+                content: [
+                    { type: 'text', text: `Pictures returned by the tool call(s) above: ${toolPictures.map((img) => img.path).join(', ')}` },
+                    ...toolPictures.map((img) => ({ type: 'image_url', image_url: { url: img.dataUrl } })),
+                ],
+            });
+            toolPictures = [];
+        };
+        request.messages.forEach((m, idx) => {
+            if (m.role !== 'tool')
+                flushToolPictures();
+            let content = m.content || "";
+            if (m.images && m.images.length > 0) {
+                if (this.options.images === false) {
+                    const note = imageNotSentText(m.images.map(img => img.path));
+                    content = m.content ? `${m.content}\n${note}` : note;
+                    if (!this.imageNoticeShown) {
+                        this.imageNoticeShown = true;
+                        this.notices.push(`${this.model} cannot read images, so the image was not sent. Switch to a model with vision (/model).`);
+                    }
+                }
+                else if (send.has(idx)) {
+                    if (m.role === 'tool') {
+                        toolPictures.push(...m.images);
                     }
-                    else if (idx === lastImageMsgIdx) {
+                    else {
                         content = [
                             { type: 'text', text: m.content || "" },
                             ...m.images.map(img => ({
@@ -128,24 +140,30 @@ export class OpenAIProvider {
                             }))
                         ];
                     }
-                    else {
-                        const imgRef = m.images.map(img => `[Attached Image: ${img.path}]`).join(' ');
-                        content = m.content ? `${m.content}\n${imgRef}` : imgRef;
-                    }
                 }
-                const msg = { role: m.role, content };
-                if (m.name)
-                    msg.name = m.name;
-                if (m.tool_calls)
-                    msg.tool_calls = m.tool_calls.map(tc => ({
-                        id: tc.id,
-                        type: 'function',
-                        function: { name: tc.name, arguments: JSON.stringify(tc.arguments) }
-                    }));
-                if (m.tool_call_id)
-                    msg.tool_call_id = m.tool_call_id;
-                return msg;
-            }),
+                else {
+                    const imgRef = m.images.map(img => `[Attached Image: ${img.path}]`).join(' ');
+                    content = m.content ? `${m.content}\n${imgRef}` : imgRef;
+                }
+            }
+            const msg = { role: m.role, content };
+            if (m.name)
+                msg.name = m.name;
+            if (m.tool_calls)
+                msg.tool_calls = m.tool_calls.map(tc => ({
+                    id: tc.id,
+                    type: 'function',
+                    function: { name: tc.name, arguments: JSON.stringify(tc.arguments) }
+                }));
+            if (m.tool_call_id)
+                msg.tool_call_id = m.tool_call_id;
+            messages.push(msg);
+        });
+        flushToolPictures();
+        const payload = {
+            model: this.model,
+            stream,
+            messages,
         };
         // Tools the gateway refused are left out; a probe is a request that costs next to nothing.
         const tools = this.toolGuard.apply(request.tools);
@@ -168,7 +186,43 @@ export class OpenAIProvider {
         }
         return payload;
     }
+    lostRequestUsage(promptTokens, completionTokens) {
+        const usage = openAiUsage({}, this.priceContext(), { prompt: promptTokens, completion: completionTokens });
+        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) {
             const errText = await res.text();
@@ -216,7 +270,7 @@ export class OpenAIProvider {
             usage
         };
     }
-    async *chatStream(request) {
+    async *streamOnce(request, watch) {
         const res = await this.send(request, true);
         if (!res.ok) {
             const errText = await res.text();
@@ -255,6 +309,7 @@ export class OpenAIProvider {
                 if (request.signal?.aborted)
                     break;
                 const { done, value } = await reader.read();
+                watch.touch();
                 if (done || request.signal?.aborted)
                     break;
                 if (value) {
@@ -388,6 +443,9 @@ export class OpenAIProvider {
         finally {
             reader.releaseLock();
         }
+        // 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();
         if (thinkBuffer.length > 0) {
             if (inThinkTag) {
                 accumulatedReasoning += thinkBuffer;

package/dist/providers/shared.js

@@ -1,4 +1,85 @@
 import { priceUsage } from '../core/prices.js';
+/** A slow model may think for minutes without a byte: the limit is generous, it is there for a dead connection. */
+export const DEFAULT_REQUEST_TIMEOUT_MS = 300_000;
+/**
+ * Gives up on a request that has gone silent. On a phone the connection can die without the app
+ * noticing (the network changes, the app sleeps), and the request would wait for ever. The timer
+ * starts with the request and starts over with every piece of data that arrives.
+ *
+ * `signal` is aborted when the time is up or when the caller's own signal is aborted; `timedOut`
+ * tells the two apart. The error it makes has the code ETIMEDOUT, which devx treats as a lost
+ * connection: the request is sent again.
+ */
+export class RequestWatchdog {
+    ms;
+    controller = new AbortController();
+    timer;
+    fired = false;
+    unlink;
+    constructor(ms, parent) {
+        this.ms = ms;
+        if (parent) {
+            if (parent.aborted)
+                this.controller.abort();
+            else {
+                const onAbort = () => this.controller.abort();
+                parent.addEventListener('abort', onAbort, { once: true });
+                this.unlink = () => parent.removeEventListener('abort', onAbort);
+            }
+        }
+        this.touch();
+    }
+    get signal() {
+        return this.controller.signal;
+    }
+    get timedOut() {
+        return this.fired;
+    }
+    /** Something arrived: the clock starts over. */
+    touch() {
+        if (!(this.ms > 0) || this.fired || this.controller.signal.aborted)
+            return;
+        clearTimeout(this.timer);
+        this.timer = setTimeout(() => {
+            this.fired = true;
+            this.controller.abort();
+        }, this.ms);
+        this.timer.unref?.();
+    }
+    stop() {
+        clearTimeout(this.timer);
+        this.unlink?.();
+        this.unlink = undefined;
+    }
+    error() {
+        const seconds = Math.round(this.ms / 1000);
+        return Object.assign(new Error(`No response from the server for ${seconds} s (the connection may have dropped)`), { code: 'ETIMEDOUT' });
+    }
+}
+/**
+ * The indexes of the messages whose pictures are really sent. Only the newest pictures go out in
+ * full; older ones become a `[Attached Image: path]` note, which keeps a long chat cheap (the
+ * model can read the file again if it needs to). Pictures that parallel tool calls returned in
+ * one step belong together, so they are all kept.
+ */
+export function imagesToSend(messages) {
+    const keep = new Set();
+    let last = -1;
+    messages.forEach((m, i) => {
+        if (m.images && m.images.length > 0)
+            last = i;
+    });
+    if (last === -1)
+        return keep;
+    keep.add(last);
+    if (messages[last].role === 'tool') {
+        for (let j = last - 1; j >= 0 && messages[j].role === 'tool'; j--) {
+            if (messages[j].images?.length)
+                keep.add(j);
+        }
+    }
+    return keep;
+}
 /**
  * Parses the JSON arguments of a tool call. Invalid JSON is reported instead of being
  * silently replaced by `{}` (a truncated write_file would otherwise look like an empty call).
@@ -80,6 +161,8 @@ export function openAiUsage(raw, ctx, fallback) {
     if (priced.cost !== undefined) {
         usage.cost = priced.cost;
         usage.costSource = guessed && priced.costSource !== 'free' ? 'estimated' : priced.costSource;
+        if (priced.parts)
+            usage.costParts = priced.parts;
     }
     return usage;
 }

package/dist/tools/fs.js

@@ -1,6 +1,8 @@
 import fs from 'fs/promises';
 import path from 'path';
 import { globalSnapshotManager } from '../core/snapshot.js';
+import { IMAGE_WARN_BYTES, imageMimeForPath, sniffImageMime } from '../core/images.js';
+import { modelAcceptsImages } from '../core/vision.js';
 // A single read result lands in the model context, so it must stay bounded.
 export const MAX_READ_CHARS = 60000;
 const MAX_READ_FILE_BYTES = 10 * 1024 * 1024;
@@ -13,12 +15,36 @@ function toLineNumber(value, name) {
     }
     return n;
 }
+/** Hands an image file to the model. The text returned here is what the tool result says. */
+async function readImage(file, size, model, context) {
+    const name = path.basename(file);
+    if (model && modelAcceptsImages(model) === false) {
+        return `[Image ${file}: the current model (${model}) cannot read images. Tell the user to switch to a model with vision (/model).]`;
+    }
+    if (!context?.attachImage) {
+        return `[Image ${file} (${size} bytes): images cannot be shown in this context]`;
+    }
+    // An image the API refuses stays in the history and breaks every following request,
+    // so the limit is the strictest one in use (Anthropic: 5 MB).
+    if (size > IMAGE_WARN_BYTES) {
+        throw new Error(`Image ${name} is ${(size / 1048576).toFixed(1)} MB: too large to show (limit ${IMAGE_WARN_BYTES / 1048576} MB). ` +
+            'Make a smaller copy first with bash (for example ImageMagick: convert in.png -resize 1600x out.png) and read that.');
+    }
+    const buffer = await fs.readFile(file);
+    const mime = sniffImageMime(buffer);
+    if (!mime) {
+        throw new Error(`${name} is not a valid PNG, JPEG, GIF or WebP image (the file contents do not match its extension)`);
+    }
+    context.attachImage({ path: file, dataUrl: `data:${mime};base64,${buffer.toString('base64')}` });
+    return `[Image ${file} (${mime}, ${(size / 1024).toFixed(0)} KB) is attached to this result: look at it]`;
+}
 export const readFileTool = {
     name: 'read_file',
     definition: {
         name: 'read_file',
         description: `Read contents of a file. Large files are returned in parts (max ~${MAX_READ_CHARS} characters per call): ` +
-            'use startLine/endLine (1-based, inclusive) to read a specific range or to continue reading.',
+            'use startLine/endLine (1-based, inclusive) to read a specific range or to continue reading. ' +
+            'Image files (png, jpg, webp, gif) are shown to you as a picture, so you can look at screenshots, photos and design mockups.',
         parameters: {
             type: 'object',
             properties: {
@@ -38,12 +64,16 @@ export const readFileTool = {
             throw new Error('endLine must be greater than or equal to startLine');
         }
     },
-    async execute(args) {
+    async execute(args, config, context) {
         try {
             const stat = await fs.stat(args.path);
             if (stat.isDirectory()) {
                 throw new Error('Path is a directory, use list_dir instead');
             }
+            // A picture is not text: it is shown to the model together with this result.
+            if (imageMimeForPath(args.path)) {
+                return await readImage(args.path, stat.size, config?.model, context);
+            }
             if (stat.size > MAX_READ_FILE_BYTES) {
                 throw new Error(`File is too large (${(stat.size / 1024 / 1024).toFixed(1)} MB). Use the search tool, or bash (e.g. head/tail/sed -n) to look at part of it`);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termux-dev",
-  "version": "1.8.2",
+  "version": "1.9.0",
   "description": "Ultra-fast, terminal-native AI coding assistant and agent built for Android Termux, Windows, macOS, and Linux.",
   "main": "dist/cli/index.js",
   "type": "module",