termux-dev 1.6.0 → 1.8.1

package/dist/providers/openai.js

@@ -1,16 +1,102 @@
-import { calculateCost } from '../core/pricing.js';
 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';
+export { parseToolArguments };
+// Fields the extra parameters may never overwrite.
+const PROTECTED_FIELDS = new Set(['model', 'messages', 'stream', 'tools', 'stream_options']);
 export class OpenAIProvider {
     baseUrl;
     apiKey;
     model;
+    extraBody;
+    options;
     id = 'openai-compatible';
-    constructor(baseUrl, apiKey, model) {
+    /** Set once the endpoint has refused the extra (reasoning) parameters: they are not sent again. */
+    extrasRejected = false;
+    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;
     }
-    buildPayload(request, stream) {
+    priceContext() {
+        return { ...this.options.price, model: this.model, baseUrl: this.baseUrl };
+    }
+    /** Messages for the user produced while talking to the endpoint (shown once). */
+    drainNotices() {
+        return this.notices.splice(0);
+    }
+    toolGuard = new ToolGuard();
+    hasActiveExtras() {
+        return !this.extrasRejected && !!this.extraBody && Object.keys(this.extraBody).length > 0;
+    }
+    /**
+     * Posts the request. If the endpoint answers 400/422 and complains about a parameter
+     * while reasoning parameters are being sent, the request is repeated once without them:
+     * an unknown setting must never make the whole session unusable.
+     */
+    async send(request, stream) {
+        const url = `${this.baseUrl}/chat/completions`;
+        const send = (body) => {
+            const bodyStr = JSON.stringify(body);
+            const headers = { 'Content-Type': 'application/json' };
+            if (this.apiKey)
+                headers['Authorization'] = `Bearer ${this.apiKey}`;
+            UsageTracker.getInstance().recordRequest(Buffer.byteLength(bodyStr, 'utf8'));
+            return fetch(url, { method: 'POST', headers, body: bodyStr, signal: request.signal });
+        };
+        const post = () => send(this.buildPayload(request, stream));
+        let res = await post();
+        if (res.ok || (res.status !== 400 && res.status !== 422))
+            return res;
+        // Refused, and it works without tools: a tool definition is what the gateway does not like.
+        if (request.tools && request.tools.length > 0 && !NOT_ABOUT_REASONING.test(errorMessageOf(await res.clone().text().catch(() => '')))) {
+            const probe = async (tools) => {
+                const body = this.buildPayload({ ...request, tools: tools.length > 0 ? tools : undefined }, false, true);
+                const r = await send(body);
+                await r.text().catch(() => '');
+                return r.ok;
+            };
+            const repair = await this.toolGuard.repair(this.toolGuard.apply(request.tools), probe);
+            if (repair.notice)
+                this.notices.push(repair.notice);
+            if (repair.changed) {
+                res = await post();
+                if (res.ok || (res.status !== 400 && res.status !== 422))
+                    return res;
+            }
+        }
+        if (!this.hasActiveExtras())
+            return res;
+        const text = await res.clone().text().catch(() => '');
+        // A gateway may word the refusal in its own way ("the model rejected this conversation or its
+        // parameters"): the reasoning setting is the one thing devx added, so it is tried without it once.
+        const known = PARAMETER_REJECTED.test(text);
+        if (!known && NOT_ABOUT_REASONING.test(errorMessageOf(text)))
+            return res;
+        this.extrasRejected = true;
+        let reason = text;
+        try {
+            const parsed = JSON.parse(text);
+            reason = parsed.error?.message || parsed.message || text;
+        }
+        catch { }
+        const retry = await post();
+        if (!known && !retry.ok) {
+            // It was not the reasoning setting: it goes on being sent, and the real answer is shown.
+            this.extrasRejected = false;
+            return retry;
+        }
+        this.notices.push(`The endpoint rejected the reasoning setting (${String(reason).replace(/\s+/g, ' ').slice(0, 110)}). ` +
+            `Continuing without it. /effort auto stops sending it for good.`);
+        return retry;
+    }
+    buildPayload(request, stream, probe = false) {
         const totalMsgs = request.messages.length;
         let lastImageMsgIdx = -1;
         for (let i = totalMsgs - 1; i >= 0; i--) {
@@ -25,7 +111,15 @@ export class OpenAIProvider {
             messages: request.messages.map((m, idx) => {
                 let content = m.content || "";
                 if (m.images && m.images.length > 0) {
-                    if (idx === lastImageMsgIdx) {
+                    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 (idx === lastImageMsgIdx) {
                         content = [
                             { type: 'text', text: m.content || "" },
                             ...m.images.map(img => ({
@@ -53,48 +147,33 @@ export class OpenAIProvider {
                 return msg;
             }),
         };
-        if (request.tools && request.tools.length > 0) {
-            payload.tools = request.tools.map(t => ({
+        // Tools the gateway refused are left out; a probe is a request that costs next to nothing.
+        const tools = this.toolGuard.apply(request.tools);
+        if (tools && tools.length > 0) {
+            payload.tools = tools.map(t => ({
                 type: 'function',
                 function: t
             }));
         }
+        if (probe)
+            payload.max_tokens = 1;
         if (stream) {
             payload.stream_options = { include_usage: true };
         }
+        if (this.hasActiveExtras()) {
+            for (const [key, value] of Object.entries(this.extraBody)) {
+                if (!PROTECTED_FIELDS.has(key))
+                    payload[key] = value;
+            }
+        }
         return payload;
     }
     async chat(request) {
-        const url = `${this.baseUrl}/chat/completions`;
-        const payload = this.buildPayload(request, false);
-        const bodyStr = JSON.stringify(payload);
-        const headers = {
-            'Content-Type': 'application/json',
-        };
-        if (this.apiKey) {
-            headers['Authorization'] = `Bearer ${this.apiKey}`;
-        }
-        UsageTracker.getInstance().recordRequest(Buffer.byteLength(bodyStr, 'utf8'));
-        const res = await fetch(url, {
-            method: 'POST',
-            headers,
-            body: bodyStr,
-            signal: request.signal
-        });
+        const res = await this.send(request, false);
         if (!res.ok) {
             const errText = await res.text();
             UsageTracker.getInstance().recordResponseChunk(Buffer.byteLength(errText, 'utf8'));
-            let errMsg = errText;
-            try {
-                const parsed = JSON.parse(errText);
-                if (parsed.error?.message) {
-                    errMsg = parsed.error.message;
-                }
-                else if (parsed.message) {
-                    errMsg = parsed.message;
-                }
-            }
-            catch { }
+            const errMsg = errorMessageOf(errText);
             const err = new Error(`Provider HTTP Error ${res.status}: ${errMsg}`);
             err.status = res.status;
             throw err;
@@ -115,77 +194,45 @@ export class OpenAIProvider {
         const choice = data.choices?.[0]?.message || {};
         let usage;
         if (data.usage) {
-            const promptTokens = data.usage.prompt_tokens || 0;
-            const completionTokens = data.usage.completion_tokens || 0;
-            const totalTokens = data.usage.total_tokens || (promptTokens + completionTokens);
-            const cost = typeof data.usage.total_cost === 'number'
-                ? data.usage.total_cost
-                : calculateCost(this.model, promptTokens, completionTokens);
-            usage = {
-                promptTokens,
-                completionTokens,
-                totalTokens,
-                cost
-            };
-            UsageTracker.getInstance().recordTokens(promptTokens, completionTokens, cost);
+            // LiteLLM puts the cost of the request into a header instead of the body.
+            const headerCost = Number(res.headers?.get?.('x-litellm-response-cost'));
+            const raw = Number.isFinite(headerCost) && res.headers.get('x-litellm-response-cost') !== null && data.usage.cost === undefined
+                ? { ...data.usage, cost: headerCost }
+                : data.usage;
+            usage = openAiUsage(raw, this.priceContext());
+            UsageTracker.getInstance().recordUsage(usage);
         }
         return {
             content: choice.content || null,
             toolCalls: choice.tool_calls ? choice.tool_calls.map((tc) => {
-                let parsedArgs = {};
-                try {
-                    parsedArgs = JSON.parse(tc.function.arguments);
-                }
-                catch {
-                    parsedArgs = {};
-                }
+                const parsed = parseToolArguments(tc.function.arguments);
                 return {
                     id: tc.id || `call_${Math.random().toString(36).substring(2, 9)}`,
                     name: tc.function.name,
-                    arguments: parsedArgs
+                    arguments: parsed.args,
+                    ...(parsed.error ? { argsError: parsed.error } : {})
                 };
             }) : undefined,
             usage
         };
     }
     async *chatStream(request) {
-        const url = `${this.baseUrl}/chat/completions`;
-        const payload = this.buildPayload(request, true);
-        const bodyStr = JSON.stringify(payload);
-        const headers = {
-            'Content-Type': 'application/json',
-        };
-        if (this.apiKey) {
-            headers['Authorization'] = `Bearer ${this.apiKey}`;
-        }
-        UsageTracker.getInstance().recordRequest(Buffer.byteLength(bodyStr, 'utf8'));
-        const res = await fetch(url, {
-            method: 'POST',
-            headers,
-            body: bodyStr,
-            signal: request.signal
-        });
+        const res = await this.send(request, true);
         if (!res.ok) {
             const errText = await res.text();
             UsageTracker.getInstance().recordResponseChunk(Buffer.byteLength(errText, 'utf8'));
-            let errMsg = errText;
-            try {
-                const parsed = JSON.parse(errText);
-                if (parsed.error?.message) {
-                    errMsg = parsed.error.message;
-                }
-                else if (parsed.message) {
-                    errMsg = parsed.message;
-                }
-            }
-            catch { }
+            const errMsg = errorMessageOf(errText);
             const err = new Error(`Provider HTTP Error ${res.status}: ${errMsg}`);
             err.status = res.status;
             throw err;
         }
         const reader = res.body?.getReader();
         if (!reader) {
-            return await this.chat(request);
+            // No streaming body: fall back to a regular request. The agent loop only reads
+            // the final response from the 'done' chunk, so it has to be yielded.
+            const fallback = await this.chat(request);
+            yield { type: 'done', response: fallback };
+            return fallback;
         }
         if (request.signal) {
             request.signal.addEventListener('abort', () => {
@@ -319,27 +366,7 @@ export class OpenAIProvider {
                                     if (tc.function?.arguments)
                                         existing.argsStr += tc.function.arguments;
                                     toolMap.set(idx, existing);
-                                    // Extract live target hint (e.g. path or command being generated)
-                                    let targetHint = undefined;
-                                    const args = existing.argsStr;
-                                    if (args) {
-                                        const pathMatch = args.match(/"(?:path|filePath|targetFile)"\s*:\s*"([^"\\]*(?:\\.[^"\\]*)*)"/);
-                                        if (pathMatch && pathMatch[1]) {
-                                            targetHint = pathMatch[1];
-                                        }
-                                        else {
-                                            const cmdMatch = args.match(/"(?:command|cmd)"\s*:\s*"([^"\\]*(?:\\.[^"\\]*)*)"/);
-                                            if (cmdMatch && cmdMatch[1]) {
-                                                targetHint = cmdMatch[1].length > 30 ? cmdMatch[1].slice(0, 27) + '...' : cmdMatch[1];
-                                            }
-                                            else {
-                                                const qMatch = args.match(/"(?:query|pattern)"\s*:\s*"([^"\\]*(?:\\.[^"\\]*)*)"/);
-                                                if (qMatch && qMatch[1]) {
-                                                    targetHint = `"${qMatch[1]}"`;
-                                                }
-                                            }
-                                        }
-                                    }
+                                    const targetHint = toolTargetHint(existing.argsStr);
                                     yield {
                                         type: 'tool_generating',
                                         name: existing.name || 'tool',
@@ -372,36 +399,22 @@ export class OpenAIProvider {
             }
         }
         const toolCalls = Array.from(toolMap.values()).map(tc => {
-            let parsedArgs = {};
-            try {
-                parsedArgs = JSON.parse(tc.argsStr);
-            }
-            catch {
-                parsedArgs = {};
-            }
+            const parsed = parseToolArguments(tc.argsStr);
             return {
                 id: tc.id || `call_${Math.random().toString(36).substring(2, 9)}`,
                 name: tc.name,
-                arguments: parsedArgs
+                arguments: parsed.args,
+                ...(parsed.error ? { argsError: parsed.error } : {})
             };
         });
         if (!accumulatedContent && !accumulatedReasoning && toolCalls.length === 0) {
             throw new Error(`Provider returned empty response (0 tokens generated). Please check your model '${this.model}', balance, or API key.`);
         }
-        let usage;
-        const promptTokens = usageData?.prompt_tokens || Math.ceil(JSON.stringify(request.messages).length / 3.5);
-        const completionTokens = usageData?.completion_tokens || Math.ceil((accumulatedContent.length + accumulatedReasoning.length) / 3.5);
-        const totalTokens = usageData?.total_tokens || (promptTokens + completionTokens);
-        const cost = typeof usageData?.total_cost === 'number'
-            ? usageData.total_cost
-            : calculateCost(this.model, promptTokens, completionTokens);
-        usage = {
-            promptTokens,
-            completionTokens,
-            totalTokens,
-            cost
-        };
-        UsageTracker.getInstance().recordTokens(promptTokens, completionTokens, cost);
+        const usage = openAiUsage(usageData, this.priceContext(), {
+            prompt: Math.ceil(JSON.stringify(request.messages).length / 3.5),
+            completion: Math.ceil((accumulatedContent.length + accumulatedReasoning.length) / 3.5),
+        });
+        UsageTracker.getInstance().recordUsage(usage);
         const finalResponse = {
             content: accumulatedContent || null,
             toolCalls: toolCalls.length > 0 ? toolCalls : undefined,

package/dist/providers/shared.js

@@ -0,0 +1,116 @@
+import { priceUsage } from '../core/prices.js';
+/**
+ * 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).
+ */
+export function parseToolArguments(raw) {
+    if (!raw || !raw.trim())
+        return { args: {} };
+    try {
+        const value = JSON.parse(raw);
+        if (value && typeof value === 'object' && !Array.isArray(value))
+            return { args: value };
+        return { args: {}, error: 'Tool arguments must be a JSON object.' };
+    }
+    catch {
+        return {
+            args: {},
+            error: 'The tool arguments were not valid JSON - the response was most likely cut off by the output token limit. ' +
+                'Nothing was executed. Retry with a smaller payload (for example, split a large file into several smaller writes).'
+        };
+    }
+}
+/** What the user should see while a tool call is still being written: the path, command or query. */
+export function toolTargetHint(args) {
+    if (!args)
+        return undefined;
+    const pathMatch = args.match(/"(?:path|filePath|targetFile)"\s*:\s*"([^"\\]*(?:\\.[^"\\]*)*)"/);
+    if (pathMatch && pathMatch[1])
+        return pathMatch[1];
+    const cmdMatch = args.match(/"(?:command|cmd)"\s*:\s*"([^"\\]*(?:\\.[^"\\]*)*)"/);
+    if (cmdMatch && cmdMatch[1])
+        return cmdMatch[1].length > 30 ? cmdMatch[1].slice(0, 27) + '...' : cmdMatch[1];
+    const qMatch = args.match(/"(?:query|pattern)"\s*:\s*"([^"\\]*(?:\\.[^"\\]*)*)"/);
+    if (qMatch && qMatch[1])
+        return `"${qMatch[1]}"`;
+    return undefined;
+}
+/** The message inside an error body of either API ({error:{message}} or {message}). */
+export function errorMessageOf(text) {
+    try {
+        const parsed = JSON.parse(text);
+        if (parsed?.error?.message)
+            return String(parsed.error.message);
+        if (typeof parsed?.error === 'string')
+            return parsed.error;
+        if (parsed?.message)
+            return String(parsed.message);
+    }
+    catch { }
+    return text;
+}
+/** What stands in the message when the model cannot read images. */
+export function imageNotSentText(paths) {
+    return paths.map((p) => `[Attached Image: ${p} - not sent, this model cannot read images]`).join(' ');
+}
+const count = (v) => (typeof v === 'number' && Number.isFinite(v) && v >= 0 ? v : 0);
+/** Usage of an OpenAI-format response, with the cost worked out. */
+export function openAiUsage(raw, ctx, fallback) {
+    const promptTokens = count(raw?.prompt_tokens) || fallback?.prompt || 0;
+    const completionTokens = count(raw?.completion_tokens) || fallback?.completion || 0;
+    const cacheRead = count(raw?.prompt_tokens_details?.cached_tokens) || count(raw?.cache_read_input_tokens) || count(raw?.prompt_cache_hit_tokens);
+    const cacheWrite = count(raw?.prompt_tokens_details?.cache_write_tokens) || count(raw?.prompt_tokens_details?.cache_creation_tokens) || count(raw?.cache_creation_input_tokens);
+    const reasoning = count(raw?.completion_tokens_details?.reasoning_tokens);
+    // The endpoint sent no token counts: the numbers are our own estimate.
+    const guessed = !count(raw?.prompt_tokens) && !count(raw?.completion_tokens) && !!fallback;
+    const usage = {
+        promptTokens,
+        completionTokens,
+        totalTokens: count(raw?.total_tokens) || promptTokens + completionTokens,
+    };
+    if (cacheRead)
+        usage.cacheReadTokens = cacheRead;
+    if (cacheWrite)
+        usage.cacheWriteTokens = cacheWrite;
+    if (reasoning)
+        usage.reasoningTokens = reasoning;
+    const priced = priceUsage(ctx, usage, raw);
+    if (guessed)
+        usage.tokensEstimated = true;
+    if (priced.cost !== undefined) {
+        usage.cost = priced.cost;
+        usage.costSource = guessed && priced.costSource !== 'free' ? 'estimated' : priced.costSource;
+    }
+    return usage;
+}
+// An error that says the request had a parameter the endpoint does not accept.
+export const PARAMETER_REJECTED = /reasoning|thinking|effort|budget|extra_body|unknown (field|parameter|argument|variable)|unrecognized|unsupported (parameter|value)|invalid (parameter|value|request)|additional propert|extra inputs|not permitted|not allowed|unexpected/i;
+// A refusal that is about something else than the reasoning setting: the size of the conversation, the key, the quota,
+// the model name. These are reported as they are; devx does not try the request again without the setting.
+export const NOT_ABOUT_REASONING = /context|too (long|large|many)|maximum|token limit|max_tokens|quota|rate limit|credit|billing|balance|api key|unauthori[sz]ed|authentication|invalid.*model|model.*(not found|does not exist)/i;
+/** Reads the data lines of a server-sent event stream; comments (heartbeats) and blanks are skipped. */
+export async function* readSseData(reader, signal, onBytes) {
+    const decoder = new TextDecoder();
+    let buffer = '';
+    while (true) {
+        if (signal?.aborted)
+            return;
+        const { done, value } = await reader.read();
+        if (done || signal?.aborted)
+            break;
+        if (value)
+            onBytes?.(value.byteLength);
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith(':') || !trimmed.startsWith('data:'))
+                continue;
+            yield trimmed.replace(/^data:\s*/, '');
+        }
+    }
+    const rest = buffer.trim();
+    if (rest.startsWith('data:'))
+        yield rest.replace(/^data:\s*/, '');
+}

package/dist/providers/toolguard.js

@@ -0,0 +1,101 @@
+/**
+ * A gateway can refuse the tool definitions of a request (a strict schema check of its own), and one
+ * odd definition from an MCP server then breaks every message. When a request is refused and it works
+ * without tools, the tools are looked at: first their schemas are simplified, and if that is not
+ * enough the ones that are refused are found (a halving search) and switched off for the session.
+ */
+const DROPPED_KEYS = new Set(['$schema', '$id', 'additionalProperties', 'default', 'examples', 'format', 'title']);
+/** A plainer copy of a JSON schema: only what every gateway accepts. */
+export function sanitizeSchema(node) {
+    if (Array.isArray(node))
+        return node.map(sanitizeSchema);
+    if (!node || typeof node !== 'object')
+        return node;
+    const out = {};
+    for (const [key, value] of Object.entries(node)) {
+        if (DROPPED_KEYS.has(key))
+            continue;
+        if (key === 'description' && typeof value === 'string') {
+            out[key] = value.replace(/\$\{/g, '$ {').slice(0, 1000);
+            continue;
+        }
+        if (key === 'required' && Array.isArray(value) && value.length === 0)
+            continue;
+        // A property called "title" is a property, not the keyword: only schema nodes are cleaned like that.
+        out[key] = key === 'properties' && value && typeof value === 'object'
+            ? Object.fromEntries(Object.entries(value).map(([name, schema]) => [name, sanitizeSchema(schema)]))
+            : sanitizeSchema(value);
+    }
+    if (out.type === 'object' && !out.properties)
+        out.properties = {};
+    return out;
+}
+export function sanitizeTool(tool) {
+    return {
+        ...tool,
+        description: String(tool.description ?? '').replace(/\$\{/g, '$ {').slice(0, 1000),
+        parameters: sanitizeSchema(tool.parameters ?? { type: 'object', properties: {} }),
+    };
+}
+export class ToolGuard {
+    sanitize = false;
+    disabled = new Set();
+    /** The tools as they are sent now: the switched-off ones left out, the schemas simplified once that was needed. */
+    apply(tools) {
+        if (!tools)
+            return tools;
+        const kept = tools.filter((t) => !this.disabled.has(t.name));
+        return this.sanitize ? kept.map(sanitizeTool) : kept;
+    }
+    get switchedOff() {
+        return [...this.disabled];
+    }
+    async findOne(list, probe) {
+        if (list.length === 0)
+            return null;
+        if (list.length === 1)
+            return list[0].name;
+        const mid = Math.ceil(list.length / 2);
+        const left = list.slice(0, mid);
+        const right = list.slice(mid);
+        if (!(await probe(left)))
+            return this.findOne(left, probe);
+        if (!(await probe(right)))
+            return this.findOne(right, probe);
+        return null; // each half is accepted alone: the trouble is in how they go together
+    }
+    /**
+     * `probe` sends the request with the given tools (and nothing that costs tokens) and says whether it was accepted.
+     * Returns whether the tools were changed and what to tell the user.
+     */
+    async repair(tools, probe) {
+        if (!tools || tools.length === 0)
+            return { changed: false };
+        // Without tools the request has to work, or the tools are not what is wrong.
+        if (!(await probe([])))
+            return { changed: false };
+        if (!this.sanitize) {
+            this.sanitize = true;
+            if (await probe(this.apply(tools))) {
+                return { changed: true, notice: 'The endpoint refused the tool definitions. They were simplified (schema extras removed) and the request works now.' };
+            }
+        }
+        const off = [];
+        for (let round = 0; round < 6; round++) {
+            const current = this.apply(tools);
+            if (current.length === 0 || (await probe(current)))
+                break;
+            const bad = await this.findOne(current, probe);
+            if (!bad)
+                break;
+            this.disabled.add(bad);
+            off.push(bad);
+        }
+        if (off.length === 0)
+            return { changed: this.sanitize };
+        return {
+            changed: true,
+            notice: `The endpoint refused ${off.length === 1 ? 'the tool' : 'the tools'} ${off.join(', ')}. ${off.length === 1 ? 'It is' : 'They are'} switched off for this session; the others work.`,
+        };
+    }
+}