termux-dev 1.8.1 → 1.9.0

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/background.js

@@ -0,0 +1,118 @@
+import { MAX_BACKGROUND_TASKS, formatDuration, getBackgroundManager } from '../core/background.js';
+const ACTIONS = ['start', 'list', 'output', 'wait', 'stop'];
+/** One line per task: `bg1 running 2m 03s  npm run dev`. */
+export function describeTask(info, now = Date.now()) {
+    const age = formatDuration((info.endedAt ?? now) - info.startedAt);
+    const state = info.status === 'running' ? 'running'
+        : info.status === 'stopped' ? 'stopped'
+            : info.status === 'exited' ? 'finished (exit 0)'
+                : `failed (exit ${info.code ?? '?'})`;
+    const watch = info.watching && info.status === 'running' ? `  [watching /${info.watching}/]` : '';
+    return `${info.id}  ${state}  ${age}  ${info.label}${watch}`;
+}
+function outputBlock(text, omitted) {
+    if (!text)
+        return '(no output)';
+    return (omitted > 0 ? `[... ${omitted} earlier line${omitted === 1 ? '' : 's'} left out ...]\n` : '') + text;
+}
+export const backgroundTool = {
+    name: 'background',
+    definition: {
+        name: 'background',
+        description: 'Run a long-lived command in the background and keep working: dev servers, file watchers, long builds or test runs. ' +
+            'Do NOT use it for commands that finish quickly (use bash). Actions: ' +
+            '"start" (command, optional label, notify_on, max_runtime_seconds) launches it and returns its id and first output; ' +
+            '"list" shows all tasks; ' +
+            '"output" (id) reads what the task printed since the last read (mode "tail" gives the last lines instead; "grep" filters lines); ' +
+            '"wait" (id, optional pattern, timeout_seconds) blocks until the task ends, a line matches the regex, or the time is up; ' +
+            '"stop" (id) ends the task. ' +
+            'Set "notify_on" (a regex such as "ready|listening|error|FAIL") to be told when such a line appears, and you are always told when a task ends: ' +
+            'then you do not need to poll. Never poll in a loop; wait with a pattern instead. ' +
+            `At most ${MAX_BACKGROUND_TASKS} tasks run at once, and all of them are stopped when devx exits.`,
+        parameters: {
+            type: 'object',
+            properties: {
+                action: { type: 'string', enum: [...ACTIONS], description: 'What to do' },
+                command: { type: 'string', description: 'start: the shell command' },
+                label: { type: 'string', description: 'start: a short name shown to the user, e.g. "dev server"' },
+                notify_on: { type: 'string', description: 'start: regex; a matching output line is reported to you' },
+                max_runtime_seconds: { type: 'number', description: 'start: stop the task after this many seconds (default: no limit)' },
+                id: { type: 'string', description: 'output / wait / stop: the task id (bg1, bg2, ...)' },
+                mode: { type: 'string', enum: ['new', 'tail'], description: 'output: "new" (default) = since the last read, "tail" = last lines' },
+                lines: { type: 'number', description: 'output: how many lines at most (default 200 for new, 40 for tail)' },
+                grep: { type: 'string', description: 'output: only lines that match this regex' },
+                pattern: { type: 'string', description: 'wait: regex of an output line to wait for (default: wait for the end)' },
+                timeout_seconds: { type: 'number', description: 'wait: give up after this long (default 60, max 600)' },
+            },
+            required: ['action'],
+        },
+    },
+    validateArgs(args) {
+        if (!args || !ACTIONS.includes(args.action))
+            throw new Error(`action must be one of: ${ACTIONS.join(', ')}`);
+        if (args.action === 'start' && (!args.command || typeof args.command !== 'string'))
+            throw new Error('command is required for "start"');
+        if (['output', 'wait', 'stop'].includes(args.action) && !args.id)
+            throw new Error(`id is required for "${args.action}" (see action "list")`);
+    },
+    async execute(args, _config, context) {
+        const manager = getBackgroundManager();
+        const action = args.action;
+        try {
+            if (action === 'start') {
+                const info = manager.start(args.command, {
+                    label: args.label,
+                    notifyOn: args.notify_on,
+                    maxRuntimeSeconds: Number(args.max_runtime_seconds) || 0,
+                });
+                // Give it a moment: a command that dies at once (wrong script, busy port) should be seen now.
+                const first = await manager.wait(info.id, { timeoutSeconds: 1.5, signal: context?.signal });
+                const now = manager.get(info.id);
+                const out = manager.read(info.id, { mode: 'new', lines: 30 });
+                const head = now.status === 'running'
+                    ? `Started ${now.id} (pid ${now.pid ?? '?'}): ${now.label}. It runs in the background.`
+                    : `${describeTask(now)} - it ended right after the start.`;
+                const hint = now.status === 'running'
+                    ? '\nYou will be told when it ends' + (now.watching ? ' or prints a line matching the pattern' : '') + '. Use "output" to read more, "wait" to wait for a line.'
+                    : '';
+                return `${head}${hint}\n${outputBlock(out.text, out.omitted)}${first.reason === 'aborted' ? '\n[Operation cancelled by user]' : ''}`;
+            }
+            if (action === 'list') {
+                const tasks = manager.list();
+                return tasks.length === 0 ? 'No background tasks.' : tasks.map((t) => describeTask(t)).join('\n');
+            }
+            if (action === 'output') {
+                const info = manager.get(String(args.id));
+                const out = manager.read(String(args.id), {
+                    mode: args.mode === 'tail' ? 'tail' : 'new',
+                    lines: args.lines,
+                    grep: args.grep,
+                });
+                return `${info ? describeTask(info) : args.id}\n${outputBlock(out.text, out.omitted)}`;
+            }
+            if (action === 'wait') {
+                const result = await manager.wait(String(args.id), {
+                    pattern: args.pattern,
+                    timeoutSeconds: Number(args.timeout_seconds) || 60,
+                    signal: context?.signal,
+                });
+                const info = manager.get(String(args.id));
+                const out = manager.read(String(args.id), { mode: 'new', lines: 60 });
+                const why = result.reason === 'match' ? `A line matched: ${result.line}`
+                    : result.reason === 'exit' ? 'The task has ended.'
+                        : result.reason === 'timeout' ? 'Timed out; the task is still running.'
+                            : '[Operation cancelled by user]';
+                return `${why}\n${describeTask(info)}\n${outputBlock(out.text, out.omitted)}`;
+            }
+            // stop
+            const before = manager.get(String(args.id));
+            if (before && before.status !== 'running')
+                return `${describeTask(before)} (already ended)`;
+            const info = await manager.stop(String(args.id));
+            return `Stopped. ${describeTask(info)}`;
+        }
+        catch (err) {
+            return `Error: ${err.message}`;
+        }
+    },
+};

package/dist/tools/bash.js

@@ -63,6 +63,8 @@ export function runShell(command, options = {}) {
         const stderrDecoder = new StringDecoder('utf8');
         let stopReason = '';
         let killTimer;
+        let killRepeat;
+        let settled = false;
         const killProcessTree = (force) => {
             if (!proc.pid)
                 return;
@@ -90,6 +92,10 @@ export function runShell(command, options = {}) {
             killProcessTree(false);
             // Commands can ignore SIGTERM. Do not leave them running after cancellation.
             killTimer = setTimeout(() => killProcessTree(true), 1000);
+            // On Windows a command such as `npm test` starts its child a moment later, after the first
+            // kill has looked at the tree: kill again until the process is gone.
+            if (isWin)
+                killRepeat = setInterval(() => killProcessTree(true), 700);
         };
         const onAbort = () => stop('[Operation cancelled by user]');
         const timeout = setTimeout(() => stop(`[Process killed due to timeout after ${timeoutSeconds}s. ` +
@@ -108,14 +114,30 @@ export function runShell(command, options = {}) {
         const cleanup = () => {
             clearTimeout(timeout);
             clearTimeout(killTimer);
+            clearInterval(killRepeat);
             signal?.removeEventListener('abort', onAbort);
         };
-        proc.on('close', (code) => {
+        const finish = (code) => {
+            if (settled)
+                return;
+            settled = true;
             if (stopReason)
                 killProcessTree(true);
             output.push(stdoutDecoder.end() + stderrDecoder.end());
             cleanup();
             resolve({ output: output.toString(), code, stopReason });
+        };
+        proc.on('close', finish);
+        // After a cancel or a timeout the shell is gone, but a child that got away can keep the pipes
+        // open for good: do not wait for them for more than a moment.
+        proc.on('exit', (code) => {
+            if (!stopReason)
+                return;
+            setTimeout(() => {
+                proc.stdout?.destroy();
+                proc.stderr?.destroy();
+                finish(code);
+            }, 300);
         });
         proc.on('error', (err) => {
             cleanup();

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/dist/tools/index.js

@@ -1,5 +1,6 @@
 import { readFileTool, writeFileTool, editFileTool, listDirTool, mkdirTool } from './fs.js';
 import { bashTool } from './bash.js';
+import { backgroundTool } from './background.js';
 import { searchTool } from './search.js';
 import { askQuestionsTool } from './questions.js';
 import { webSearchTool, fetchUrlTool } from './web.js';
@@ -17,6 +18,6 @@ export function getTools(planMode) {
     if (planMode) {
         return [...baseTools, ...mcpTools];
     }
-    return [...baseTools, writeFileTool, editFileTool, mkdirTool, bashTool, diagnoseCodeTool, installPackageTool, servePreviewTool, mcpManageTool, ...mcpTools];
+    return [...baseTools, writeFileTool, editFileTool, mkdirTool, bashTool, backgroundTool, diagnoseCodeTool, installPackageTool, servePreviewTool, mcpManageTool, ...mcpTools];
 }
 export { webSearchTool, fetchUrlTool, diagnoseCodeTool, installPackageTool, saveMemoryTool, planReadyTool, lastPlanReady, resetPlanReady, todoListTool, currentTodoList, resetTodoList, servePreviewTool };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termux-dev",
-  "version": "1.8.1",
+  "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",