@datename/fastcode-termux 0.1.6 → 0.1.8-beta.0

package/src/patch/plan.ts

@@ -0,0 +1,317 @@
+import { closeSync, constants as fsConstants, lstatSync, openSync, readFileSync } from "node:fs";
+import { basename } from "node:path";
+import { sandboxPath } from "../agent/tools/paths.js";
+import { parsePatch, type PatchHunk, type PatchOp } from "./parse.js";
+
+export interface PlannedFile {
+    kind: "add" | "delete" | "update";
+    relPath: string;
+    path: string;
+    moveRel?: string;
+    moveTo?: string;
+    existed: boolean;
+    origMode: number;
+    eol: "\n" | "\r\n";
+    oldContent?: string;
+    newContent?: string;
+    diff: string;
+    changedLines: number;
+}
+
+export interface PatchPlan {
+    files: PlannedFile[];
+    warnings: string[];
+}
+
+export type PlanResult = { ok: true; plan: PatchPlan } | { ok: false; output: string };
+
+export type PatchReview =
+    | { kind: "allow" }
+    | { kind: "deny"; reason: string }
+    | { kind: "pending"; reason: string; changedLines: number };
+
+export function planPatch(patch: string, cwd: string): PlanResult {
+    const parsed = parsePatch(patch);
+    if (parsed.ok === false)
+        return { ok: false, output: parsed.output };
+    const files: PlannedFile[] = [];
+    const warnings: string[] = [];
+    for (const op of parsed.ops) {
+        const planned = planOp(op, cwd, warnings);
+        if (planned.ok === false)
+            return { ok: false, output: planned.output };
+        files.push(planned.file);
+    }
+    return { ok: true, plan: { files, warnings } };
+}
+
+function planOp(op: PatchOp, cwd: string, warnings: string[]): { ok: true; file: PlannedFile } | { ok: false; output: string } {
+    try {
+        const path = sandboxPath(cwd, op.path);
+        if (op.kind === "add") {
+            if (lexists(path))
+                return { ok: false, output: `Add File target already exists: ${op.path}` };
+            const newContent = op.lines.length > 0 ? op.lines.join("\n") + "\n" : "";
+            return {
+                ok: true,
+                file: {
+                    kind: "add",
+                    relPath: op.path,
+                    path,
+                    existed: false,
+                    origMode: 0o644,
+                    eol: "\n",
+                    newContent,
+                    diff: makeDiff(null, op.path, "", newContent, "add"),
+                    changedLines: newContent.split("\n").filter(Boolean).length,
+                },
+            };
+        }
+        if (!lexists(path))
+            return { ok: false, output: `file not found: ${op.path}` };
+        const info = lstatSync(path);
+        if (info.isSymbolicLink())
+            return { ok: false, output: `refusing to patch a symbolic link: ${op.path}` };
+        if (!info.isFile())
+            return { ok: false, output: `not a regular file: ${op.path}` };
+        const oldContent = readNoFollow(path);
+        if (op.kind === "delete") {
+            return {
+                ok: true,
+                file: {
+                    kind: "delete",
+                    relPath: op.path,
+                    path,
+                    existed: true,
+                    origMode: info.mode & 0o777,
+                    eol: detectEol(oldContent),
+                    oldContent,
+                    diff: makeDiff(op.path, null, oldContent, "", "delete"),
+                    changedLines: oldContent.split(/\r?\n/).length,
+                },
+            };
+        }
+        const eol = detectEol(oldContent);
+        if (eol === "\n" && /\r\n/.test(oldContent))
+            warnings.push(`mixed line endings in ${op.path}; writing LF`);
+        let newContent = oldContent;
+        if (op.hunks.length > 0) {
+            const applied = applyHunks(oldContent, op.hunks);
+            if (applied.ok === false)
+                return applied;
+            newContent = applied.content;
+            if (eol === "\r\n")
+                newContent = newContent.replace(/\n/g, "\r\n");
+        }
+        let moveTo: string | undefined;
+        let moveRel: string | undefined;
+        if (op.moveTo) {
+            moveTo = sandboxPath(cwd, op.moveTo);
+            if (lexists(moveTo))
+                return { ok: false, output: `Move target already exists: ${op.moveTo}` };
+            moveRel = op.moveTo;
+        }
+        const diff = makeDiff(op.path, op.moveTo ?? op.path, oldContent, newContent, "update");
+        return {
+            ok: true,
+            file: {
+                kind: "update",
+                relPath: op.path,
+                path,
+                moveRel,
+                moveTo,
+                existed: true,
+                origMode: info.mode & 0o777,
+                eol,
+                oldContent,
+                newContent,
+                diff,
+                changedLines: countChangedLines(oldContent, newContent),
+            },
+        };
+    }
+    catch (err: any) {
+        return { ok: false, output: err?.message ?? String(err) };
+    }
+}
+
+export function reviewPatchPlan(plan: PatchPlan): PatchReview {
+    let changed = 0;
+    for (const file of plan.files) {
+        changed += file.changedLines;
+        if (isHardDenied(file.path))
+            return { kind: "deny", reason: `patch targets a protected path: ${file.relPath}` };
+        if (isSensitivePath(file.path))
+            return { kind: "pending", reason: `patch targets a sensitive path: ${file.relPath}`, changedLines: changed };
+    }
+    if (changed > 200)
+        return { kind: "pending", reason: `patch changes ${changed} lines (limit 200)`, changedLines: changed };
+    return { kind: "allow" };
+}
+
+function isHardDenied(path: string): boolean {
+    const normalized = path.replace(/\\/g, "/").toLowerCase();
+    const segments = normalized.split("/");
+    if (segments.includes(".ssh") || segments.includes(".gnupg"))
+        return true;
+    if (normalized.includes("/.git/hooks/"))
+        return true;
+    if (normalized.includes("/android/data/"))
+        return true;
+    const name = basename(normalized);
+    return name === "auth.json" || name === "trust.json";
+}
+
+function isSensitivePath(path: string): boolean {
+    const normalized = path.replace(/\\/g, "/").toLowerCase();
+    const name = basename(normalized);
+    return name === ".env" || name.startsWith(".env.") || /[.](pem|key|p12|pfx)$/.test(name) || normalized.includes("/.git/hooks/");
+}
+
+function lexists(path: string): boolean {
+    try {
+        lstatSync(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+
+function readNoFollow(path: string): string {
+    const flags = fsConstants.O_RDONLY | (fsConstants.O_NOFOLLOW ?? 0);
+    const fd = openSync(path, flags);
+    try {
+        return readFileSync(fd, "utf8");
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+
+export function detectEol(content: string): "\n" | "\r\n" {
+    const crlf = (content.match(/\r\n/g) ?? []).length;
+    const lf = (content.match(/\n/g) ?? []).length;
+    return crlf > 0 && crlf === lf ? "\r\n" : "\n";
+}
+
+type ApplyHunksResult = { ok: true; content: string } | { ok: false; output: string };
+
+export function applyHunks(oldContent: string, hunks: PatchHunk[]): ApplyHunksResult {
+    const lines = oldContent.split(/\r?\n/);
+    let changed = false;
+    for (const hunk of hunks) {
+        const needle = hunk.lines.filter((line) => line.type !== "+").map((line) => line.text);
+        const replacement = hunk.lines.filter((line) => line.type !== "-").map((line) => line.text);
+        if (needle.length === 0) {
+            const at = lines.length > 0 && lines[lines.length - 1] === "" ? lines.length - 1 : lines.length;
+            lines.splice(at, 0, ...replacement);
+            changed = true;
+            continue;
+        }
+        const verdict = findHunk(lines, needle);
+        if (verdict.ok === false)
+            return verdict;
+        lines.splice(verdict.index, needle.length, ...replacement);
+        changed = true;
+    }
+    if (!changed)
+        return { ok: false, output: "patch made no changes" };
+    return { ok: true, content: lines.join("\n") };
+}
+
+function findHunk(lines: string[], needle: string[]): { ok: true; index: number } | { ok: false; output: string } {
+    for (let level = 0; level < 3; level += 1) {
+        const matches = matchAll(lines, needle, level);
+        if (matches.length === 0)
+            continue;
+        if (matches.length > 1) {
+            return {
+                ok: false,
+                output: `ambiguous patch context (${matches.length} candidates at lines ${matches.map((index) => index + 1).join(", ")}); add surrounding context`,
+            };
+        }
+        return { ok: true, index: matches[0] };
+    }
+    return { ok: false, output: `patch context not found: ${JSON.stringify(needle.slice(0, 4))}` };
+}
+
+function matchAll(lines: string[], needle: string[], level: number): number[] {
+    const found: number[] = [];
+    const wanted = needle.map((line) => normalizeLine(line, level));
+    for (let i = 0; i + needle.length <= lines.length; i += 1) {
+        let match = true;
+        for (let j = 0; j < needle.length; j += 1) {
+            if (normalizeLine(lines[i + j], level) !== wanted[j]) {
+                match = false;
+                break;
+            }
+        }
+        if (match)
+            found.push(i);
+    }
+    return found;
+}
+
+function normalizeLine(line: string, level: number): string {
+    if (level === 0)
+        return line;
+    if (level === 1)
+        return line.replace(/\s+$/, "");
+    return line.replace(/\s+/g, " ").trim();
+}
+
+export function makeDiff(oldPath: string | null, newPath: string | null, oldContent: string, newContent: string, kind: "add" | "delete" | "update"): string {
+    const oldLines = splitDiffLines(oldContent);
+    const newLines = splitDiffLines(newContent);
+    let prefix = 0;
+    while (prefix < oldLines.length && prefix < newLines.length && oldLines[prefix] === newLines[prefix])
+        prefix += 1;
+    let suffix = 0;
+    while (suffix < oldLines.length - prefix && suffix < newLines.length - prefix &&
+        oldLines[oldLines.length - 1 - suffix] === newLines[newLines.length - 1 - suffix])
+        suffix += 1;
+    const oldMiddle = oldLines.slice(prefix, oldLines.length - suffix);
+    const newMiddle = newLines.slice(prefix, newLines.length - suffix);
+    const oldStart = prefix + 1;
+    const newStart = prefix + 1;
+    const header = kind === "add"
+        ? `--- /dev/null\n+++ b/${newPath ?? ""}`
+        : kind === "delete"
+            ? `--- a/${oldPath ?? ""}\n+++ /dev/null`
+            : `--- a/${oldPath ?? ""}\n+++ b/${newPath ?? oldPath ?? ""}`;
+    const body = [
+        `@@ -${oldStart},${oldMiddle.length} +${newStart},${newMiddle.length} @@`,
+        ...oldMiddle.map((line) => "-" + line),
+        ...newMiddle.map((line) => "+" + line),
+    ];
+    return [header, ...body].join("\n");
+}
+
+function splitDiffLines(content: string): string[] {
+    if (content === "")
+        return [];
+    const lines = content.split(/\r?\n/);
+    if (lines.length > 0 && lines[lines.length - 1] === "")
+        lines.pop();
+    return lines;
+}
+
+function countChangedLines(oldContent: string, newContent: string): number {
+    const oldLines = oldContent.split(/\r?\n/);
+    const newLines = newContent.split(/\r?\n/);
+    let changed = 0;
+    let i = 0;
+    let j = 0;
+    while (i < oldLines.length && j < newLines.length) {
+        if (oldLines[i] === newLines[j]) {
+            i += 1;
+            j += 1;
+            continue;
+        }
+        changed += 1;
+        i += 1;
+        j += 1;
+    }
+    return changed + Math.abs(oldLines.length - newLines.length);
+}

package/src/providers/anthropic.ts

@@ -10,12 +10,16 @@ const STATIC_MODELS = [
     { id: "claude-haiku-4.5", label: "Claude Haiku 4.5" },
 ];
 const BASE = "https://api.anthropic.com/v1";
+const THINKING_BUDGETS = { low: 1024, medium: 4096, high: 8192, max: 16000 };
 export const anthropicProvider = {
     id: "anthropic",
     label: "Anthropic (Claude)",
     authEnv: ["ANTHROPIC_API_KEY", "CLAUDE_API_KEY"],
     baseUrl: BASE,
     defaultModel: "claude-sonnet-5.5",
+    supportsReasoning() {
+        return true;
+    },
     async listModels(apiKey) {
         // Query the live model list; fall back to the built-in list offline.
         if (apiKey) {
@@ -45,7 +49,7 @@ export const anthropicProvider = {
             throw new Error("Missing ANTHROPIC_API_KEY. Bind one with /login anthropic <model> <key>, or set the env var.");
         }
         const messages = req.messages.map((m) => ({ role: m.role, content: m.content }));
-        const body = {
+        const body: any = {
             model: req.model,
             messages,
             ...(req.system ? { system: req.system } : {}),
@@ -53,6 +57,14 @@ export const anthropicProvider = {
             max_tokens: req.maxOutputTokens ?? 4096,
             ...(req.temperature !== undefined ? { temperature: req.temperature } : {}),
         };
+        if (req.reasoningEffort && req.reasoningEffort !== "auto") {
+            const budget = THINKING_BUDGETS[req.reasoningEffort] ?? THINKING_BUDGETS.medium;
+            body.thinking = { type: "enabled", budget_tokens: budget };
+            // max_tokens must exceed the thinking budget.
+            body.max_tokens = Math.max(body.max_tokens, budget + 1024);
+            // Extended thinking is incompatible with a custom temperature.
+            delete body.temperature;
+        }
         const res = await fetch(BASE + "/messages", {
             method: "POST",
             headers: {

package/src/providers/deepseek.ts

@@ -9,7 +9,8 @@ export const deepseekProvider = {
     label: "DeepSeek",
     authEnv: ["DEEPSEEK_API_KEY"],
     baseUrl: BASE,
-    defaultModel: "deepseek-v4-pro",
+    defaultModel: "deepseek-flash",
     listModels: (apiKey) => listModelsHttp({ baseUrl: BASE, apiKey, staticModels: STATIC }),
-    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC }),
+    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC, reasoning: "openai" }),
+    supportsReasoning: () => true,
 };

package/src/providers/groq.ts

@@ -16,5 +16,6 @@ export const groqProvider = {
     baseUrl: BASE,
     defaultModel: "llama-3.3-70b-versatile",
     listModels: (apiKey) => listModelsHttp({ baseUrl: BASE, apiKey, staticModels: STATIC }),
-    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC }),
+    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC, reasoning: "openai" }),
+    supportsReasoning: () => true,
 };

package/src/providers/index.ts

@@ -11,7 +11,8 @@ import { moonshotProvider } from "./moonshot.js";
 import { zhipuProvider } from "./zhipu.js";
 import { qwenProvider } from "./qwen.js";
 import { customProvider } from "./custom.js";
-export const PROVIDERS = [
+import type { Provider } from "../types.js";
+export const PROVIDERS: Provider[] = [
     anthropicProvider,
     openaiProvider,
     googleProvider,
@@ -35,3 +36,33 @@ export function getProviderOrThrow(id) {
         throw new Error("Unknown provider: " + id);
     return p;
 }
+/**
+ * Cheap connectivity check used by the model picker to label a list "offline".
+ * `listModels()` silently falls back to the static list, so without this probe
+ * the UI cannot tell a live catalog from a cached one.
+ */
+export async function probeProvider(provider, apiKey, timeoutMs = 4000) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const base = String(provider.baseUrl).replace(/[/]+$/, "");
+        const headers = { accept: "application/json" };
+        if (apiKey) {
+            if (provider.id === "anthropic") {
+                headers["x-api-key"] = apiKey;
+                headers["anthropic-version"] = "2023-06-01";
+            }
+            else {
+                headers["authorization"] = "Bearer " + apiKey;
+            }
+        }
+        const res = await fetch(base + "/models", { headers, signal: controller.signal });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/src/providers/mistral.ts

@@ -15,5 +15,6 @@ export const mistralProvider = {
     baseUrl: BASE,
     defaultModel: "mistral-small-latest",
     listModels: (apiKey) => listModelsHttp({ baseUrl: BASE, apiKey, staticModels: STATIC }),
-    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC }),
+    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC, reasoning: "openai" }),
+    supportsReasoning: () => true,
 };

package/src/providers/moonshot.ts

@@ -18,5 +18,6 @@ export const moonshotProvider = {
     },
     defaultModel: "kimi-k3",
     listModels: (apiKey) => listModelsHttp({ baseUrl: baseUrl(), apiKey, staticModels: STATIC }),
-    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: baseUrl(), apiKey, staticModels: STATIC }),
+    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: baseUrl(), apiKey, staticModels: STATIC, reasoning: "openai" }),
+    supportsReasoning: () => true,
 };

package/src/providers/openai.ts

@@ -21,5 +21,6 @@ export const openaiProvider = {
     baseUrl: BASE,
     defaultModel: "gpt-6-luna",
     listModels: (apiKey) => listModelsHttp({ baseUrl: BASE, apiKey, staticModels: STATIC }),
-    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC }),
+    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC, reasoning: "openai" }),
+    supportsReasoning: (model) => /^(o\d|gpt-5|gpt-6)/i.test(model),
 };

package/src/providers/openaiCompatible.ts

@@ -1,12 +1,69 @@
 import { fetchJson, streamSSE } from "../lib/http.js";
+import { finalizeToolCalls, mergeToolCallDelta, type ToolCallAccumulator } from "../lib/native-tools.js";
+import { buildHeaders, buildRequestUrl, type RequestSpec } from "./spec.js";
+
+export interface ModelInfo {
+    id: string;
+    label?: string;
+    [key: string]: any;
+}
+
+export interface StreamOptions {
+    baseUrl: string;
+    apiKey?: string;
+    chatPath?: string;
+    modelsPath?: string | null;
+    query?: Record<string, string>;
+    pathParams?: Record<string, string>;
+    authHeaderName?: string;
+    authPrefix?: string;
+    staticModels?: ModelInfo[];
+    extraHeaders?: Record<string, string>;
+    /** Legacy auth prefix, e.g. "Bearer". Prefer authPrefix for new callers. */
+    authHeader?: string;
+    reasoning?: "openai" | "openrouter" | "none" | string;
+}
+
+export function toRequestSpec(opts: StreamOptions): RequestSpec {
+    return {
+        baseUrl: trim(opts.baseUrl),
+        chatPath: opts.chatPath,
+        modelsPath: opts.modelsPath,
+        query: opts.query,
+        pathParams: opts.pathParams,
+        authHeaderName: opts.authHeaderName,
+        authPrefix: opts.authPrefix ?? (opts.authHeader !== undefined ? `${opts.authHeader} ` : undefined),
+    };
+}
 /** Build a chat-completions body in the classic or the newer (compat) dialect. */
-function buildBody(req, compat) {
+function buildBody(req: any, compat: boolean, opts: StreamOptions, includeReasoning = true) {
     const messages = [];
     if (req.system)
         messages.push({ role: "system", content: req.system });
-    for (const m of req.messages)
+    for (const m of req.messages) {
+        if (m.role === "tool") {
+            messages.push({ role: "tool", tool_call_id: m.toolCallId, content: m.content });
+            continue;
+        }
+        if (m.role === "assistant" && m.toolCalls && m.toolCalls.length > 0) {
+            messages.push({
+                role: "assistant",
+                content: m.content || null,
+                tool_calls: m.toolCalls.map((call) => ({
+                    id: call.id,
+                    type: "function",
+                    function: { name: call.name, arguments: call.arguments },
+                })),
+            });
+            continue;
+        }
         messages.push({ role: m.role, content: m.content });
+    }
     const body: any = { model: req.model, messages, stream: true };
+    if (req.tools && req.tools.length > 0) {
+        body.tools = req.tools;
+        body.tool_choice = "auto";
+    }
     if (req.maxOutputTokens !== undefined) {
         if (compat)
             body.max_completion_tokens = req.maxOutputTokens;
@@ -15,38 +72,56 @@ function buildBody(req, compat) {
     }
     if (req.temperature !== undefined && !compat)
         body.temperature = req.temperature;
+    if (includeReasoning && req.reasoningEffort && req.reasoningEffort !== "auto") {
+        const effort = req.reasoningEffort === "max" ? "high" : req.reasoningEffort;
+        if (opts.reasoning === "openai")
+            body.reasoning_effort = effort;
+        else if (opts.reasoning === "openrouter")
+            body.reasoning = { effort };
+    }
     return body;
 }
-export async function* streamChatCompletion(req, opts) {
-    const send = async (compat) => {
-        const headers = {
+export async function* streamChatCompletion(req: any, opts: StreamOptions) {
+    const hasReasoning = Boolean(req.reasoningEffort && req.reasoningEffort !== "auto" && opts.reasoning && opts.reasoning !== "none");
+    const spec = toRequestSpec(opts);
+    const send = async (compat, includeReasoning = hasReasoning) => {
+        const headers: Record<string, string> = {
             "content-type": "application/json",
             accept: "text/event-stream",
             ...(opts.extraHeaders ?? {}),
         };
         if (opts.apiKey)
-            headers["authorization"] = (opts.authHeader ?? "Bearer") + " " + opts.apiKey;
-        return await fetch(trim(opts.baseUrl) + "/chat/completions", {
+            Object.assign(headers, buildHeaders(spec, opts.apiKey));
+        if (req.clientRequestId)
+            headers["idempotency-key"] = req.clientRequestId;
+        return await fetch(buildRequestUrl(spec, opts.chatPath ?? "/chat/completions"), {
             method: "POST",
             headers,
-            body: JSON.stringify(buildBody(req, compat)),
+            body: JSON.stringify(buildBody(req, compat, opts, includeReasoning)),
             signal: req.signal,
         });
     };
     let res = await send(false);
     if (!res.ok) {
-        const detail = await res.text().catch(() => "");
+        let detail = await res.text().catch(() => "");
+        // Some models reject the thinking parameter even though the provider
+        // as a whole accepts it. Drop it once, then keep the request alive.
+        if (res.status === 400 && hasReasoning && /reasoning|thinking|effort|unsupported|unrecognized|unknown parameter/i.test(detail)) {
+            res = await send(false, false);
+            detail = res.ok ? detail : await res.text().catch(() => "");
+        }
         // Newer OpenAI-style models reject max_tokens and temperature. Retry once
         // in the compatibility dialect before surfacing the real error.
-        if (res.status === 400 && /max_tokens|max_completion_tokens|temperature|unsupported|unrecognized|unknown parameter/i.test(detail)) {
-            res = await send(true);
+        if (!res.ok && res.status === 400 && /max_tokens|max_completion_tokens|temperature|unsupported|unrecognized|unknown parameter/i.test(detail)) {
+            res = await send(true, false);
+            detail = res.ok ? detail : await res.text().catch(() => "");
         }
         if (!res.ok) {
-            const body = await res.text().catch(() => "");
-            throw new Error(res.status + " " + res.statusText + ": " + body.slice(0, 500));
+            throw new Error(res.status + " " + res.statusText + ": " + detail.slice(0, 500));
         }
     }
     let usage;
+    const toolCalls: ToolCallAccumulator = new Map();
     for await (const ev of streamSSE(res)) {
         if (ev.data === "[DONE]")
             break;
@@ -61,6 +136,14 @@ export async function* streamChatCompletion(req, opts) {
         const choice = obj.choices?.[0];
         const raw = choice?.delta?.content ?? choice?.text;
         const reasoning = choice?.delta?.reasoning_content ?? choice?.delta?.reasoning;
+        if (Array.isArray(choice?.delta?.tool_calls)) {
+            for (const delta of choice.delta.tool_calls)
+                mergeToolCallDelta(toolCalls, delta);
+        }
+        if (Array.isArray(choice?.message?.tool_calls)) {
+            for (const delta of choice.message.tool_calls)
+                mergeToolCallDelta(toolCalls, delta);
+        }
         if (obj.usage) {
             usage = {
                 inputTokens: obj.usage.prompt_tokens,
@@ -78,17 +161,19 @@ export async function* streamChatCompletion(req, opts) {
         else if (typeof reasoning === "string" && reasoning)
             yield { delta: "", done: false, reasoning };
     }
-    yield { delta: "", done: true, usage };
+    const calls = finalizeToolCalls(toolCalls);
+    yield calls.length > 0 ? { delta: "", done: true, usage, toolCalls: calls } : { delta: "", done: true, usage };
 }
-export async function listModelsHttp(opts) {
+export async function listModelsHttp(opts: StreamOptions) {
     const staticModels = opts.staticModels ?? [];
+    if (opts.modelsPath === null)
+        return staticModels;
     if (!opts.apiKey && staticModels.length)
         return staticModels;
     try {
-        const headers = {};
-        if (opts.apiKey)
-            headers["authorization"] = (opts.authHeader ?? "Bearer") + " " + opts.apiKey;
-        const json = await fetchJson(trim(opts.baseUrl) + "/models", { headers });
+        const spec = toRequestSpec(opts);
+        const headers = opts.apiKey ? buildHeaders(spec, opts.apiKey) : {};
+        const json = await fetchJson(buildRequestUrl(spec, opts.modelsPath ?? "/models"), { headers });
         const ids = (json.data ?? [])
             .map((m) => m.id)
             .filter((id) => typeof id === "string" && id.length > 0);

package/src/providers/openrouter.ts

@@ -22,5 +22,6 @@ export const openrouterProvider = {
     baseUrl: BASE,
     defaultModel: "anthropic/claude-sonnet-5.5",
     listModels: (apiKey) => listModelsHttp({ baseUrl: BASE, apiKey, staticModels: STATIC, extraHeaders: EXTRA_HEADERS }),
-    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC, extraHeaders: EXTRA_HEADERS }),
+    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC, extraHeaders: EXTRA_HEADERS, reasoning: "openrouter" }),
+    supportsReasoning: () => true,
 };

package/src/providers/qwen.ts

@@ -19,5 +19,6 @@ export const qwenProvider = {
     },
     defaultModel: "qwen3.8-max",
     listModels: (apiKey) => listModelsHttp({ baseUrl: baseUrl(), apiKey, staticModels: STATIC }),
-    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: baseUrl(), apiKey, staticModels: STATIC }),
+    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: baseUrl(), apiKey, staticModels: STATIC, reasoning: "openai" }),
+    supportsReasoning: () => true,
 };