@datename/fastcode-termux 0.1.6-beta → 0.1.6

package/src/config/trust.ts

@@ -7,30 +7,11 @@
  *
  * FASTCODE_TRUST_ALL=1 marks every directory trusted (scripts, CI).
  */
-import { existsSync, readFileSync, realpathSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { ensureDir, getPaths } from "./paths.js";
-
 const TRUTHY = ["1", "true", "yes", "on"];
-
-export interface TrustPathEntry {
-    grantedAt: string;
-    lastUsed: string;
-}
-
-export interface TrustToolEntry extends TrustPathEntry {
-    catalogHash: string;
-}
-
-export interface TrustStore {
-    version: 1;
-    tools: Record<string, TrustToolEntry>;
-    paths: Record<string, TrustPathEntry>;
-}
-
-let cache: { file: string; key: string; state: TrustStore } | undefined;
-
-export function normalizeProjectPath(dir: string): string {
+export function normalizeProjectPath(dir) {
     const absolute = resolve(dir);
     try {
         return realpathSync(absolute);
@@ -39,145 +20,48 @@ export function normalizeProjectPath(dir: string): string {
         return absolute;
     }
 }
-
-function emptyStore(): TrustStore {
-    return { version: 1, tools: {}, paths: {} };
-}
-
-function normalizePaths(raw: any): Record<string, TrustPathEntry> {
-    const paths: Record<string, TrustPathEntry> = {};
-    if (!raw || typeof raw !== "object")
-        return paths;
-    for (const [key, value] of Object.entries<any>(raw)) {
-        if (!key || !value || typeof value !== "object")
-            continue;
-        paths[key] = {
-            grantedAt: typeof value.grantedAt === "string" ? value.grantedAt : "",
-            lastUsed: typeof value.lastUsed === "string" ? value.lastUsed : "",
-        };
-    }
-    return paths;
-}
-
-function normalizeTools(raw: any): Record<string, TrustToolEntry> {
-    const tools: Record<string, TrustToolEntry> = {};
-    if (!raw || typeof raw !== "object")
-        return tools;
-    for (const [key, value] of Object.entries<any>(raw)) {
-        if (!key || !value || typeof value !== "object" || typeof value.catalogHash !== "string")
-            continue;
-        tools[key] = {
-            grantedAt: typeof value.grantedAt === "string" ? value.grantedAt : "",
-            lastUsed: typeof value.lastUsed === "string" ? value.lastUsed : "",
-            catalogHash: value.catalogHash,
-        };
-    }
-    return tools;
-}
-
-function migrateLegacy(raw: any): TrustStore | undefined {
-    if (!raw || typeof raw !== "object" || !Array.isArray(raw.trusted))
-        return undefined;
-    const store = emptyStore();
-    for (const entry of raw.trusted) {
-        if (!entry || typeof entry.path !== "string" || !entry.path)
-            continue;
-        const at = typeof entry.addedAt === "string" ? entry.addedAt : new Date().toISOString();
-        store.paths[entry.path] = { grantedAt: at, lastUsed: at };
-    }
-    return store;
-}
-
-function readStore(file: string): TrustStore {
-    if (!existsSync(file))
-        return emptyStore();
-    try {
-        const raw = JSON.parse(readFileSync(file, "utf8"));
-        if (raw && raw.version === 1) {
-            return {
-                version: 1,
-                tools: normalizeTools(raw.tools),
-                paths: normalizePaths(raw.paths),
-            };
-        }
-        const migrated = migrateLegacy(raw);
-        if (!migrated)
-            return emptyStore();
-        try {
-            writeFileSync(file, JSON.stringify(migrated, null, 2), "utf8");
-        }
-        catch {
-            // A read-only home still gets the migrated view in memory.
-        }
-        return migrated;
-    }
-    catch {
-        return emptyStore();
-    }
-}
-
-export function loadTrust(): TrustStore {
+export function loadTrust() {
     const { trust } = getPaths();
-    let key = "missing";
+    if (!existsSync(trust))
+        return { trusted: [] };
     try {
-        const info = statSync(trust);
-        key = `${info.mtimeMs}:${info.size}`;
+        const raw = JSON.parse(readFileSync(trust, "utf8"));
+        return { trusted: Array.isArray(raw.trusted) ? raw.trusted.filter((entry) => entry && typeof entry.path === "string") : [] };
     }
     catch {
-        // Missing file: cache the empty store until it appears.
+        return { trusted: [] };
     }
-    if (cache && cache.file === trust && cache.key === key)
-        return cache.state;
-    const state = readStore(trust);
-    cache = { file: trust, key, state };
-    return state;
 }
-
-function saveTrust(state: TrustStore): void {
+function saveTrust(state) {
     const paths = getPaths();
     ensureDir(paths.root);
     writeFileSync(paths.trust, JSON.stringify(state, null, 2), "utf8");
-    try {
-        const info = statSync(paths.trust);
-        cache = { file: paths.trust, key: `${info.mtimeMs}:${info.size}`, state };
-    }
-    catch {
-        cache = undefined;
-    }
 }
-
-export function trustAllEnabled(): boolean {
+export function trustAllEnabled() {
     return TRUTHY.includes((process.env["FASTCODE_TRUST_ALL"] ?? "").trim().toLowerCase());
 }
-
-export function isTrusted(dir: string): boolean {
+export function isTrusted(dir) {
     if (trustAllEnabled())
         return true;
     const target = normalizeProjectPath(dir);
-    return Boolean(loadTrust().paths[target]);
+    return loadTrust().trusted.some((entry) => entry.path === target);
 }
-
-export function trustProject(dir: string): string {
+export function trustProject(dir) {
     const target = normalizeProjectPath(dir);
     const state = loadTrust();
-    if (!state.paths[target]) {
-        const at = new Date().toISOString();
-        state.paths[target] = { grantedAt: at, lastUsed: at };
+    if (!state.trusted.some((entry) => entry.path === target)) {
+        state.trusted.push({ path: target, addedAt: new Date().toISOString() });
         saveTrust(state);
     }
     return target;
 }
-
-export function untrustProject(dir: string): boolean {
+export function untrustProject(dir) {
     const target = normalizeProjectPath(dir);
     const state = loadTrust();
-    if (!state.paths[target])
-        return false;
-    delete state.paths[target];
-    saveTrust(state);
-    return true;
+    const next = state.trusted.filter((entry) => entry.path !== target);
+    saveTrust({ trusted: next });
+    return state.trusted.length !== next.length;
 }
-
-export function listTrusted(): Array<{ path: string; addedAt: string }> {
-    return Object.entries(loadTrust().paths).map(([path, entry]) => ({ path, addedAt: entry.grantedAt }));
+export function listTrusted() {
+    return loadTrust().trusted;
 }

package/src/lib/diagnostics.ts

@@ -5,8 +5,6 @@
  * diagnosed without opening the TUI: Node version, Termux detection, whether
  * stdout is a real terminal, the config root, and which provider keys exist.
  */
-import { existsSync, statSync } from "node:fs";
-import { totalmem, freemem, tmpdir as osTmpdir } from "node:os";
 import { detectPlatform, platformLabel } from "./platform.js";
 import { readPackageMeta } from "./pkg.js";
 import { shouldUseStableTerminalUi } from "./uiMode.js";
@@ -15,14 +13,10 @@ import { loadConfig, resolveApiKey, resolveProviderKey } from "../config/store.j
 import { PROVIDERS } from "../providers/index.js";
 import { listInstalledSkills } from "../skills/manager.js";
 import { listInstalledPlugins } from "../plugins/manager.js";
-import { findUnclosedSessions, fsyncMode, loggingEnabled, listSessions, sessionCacheLimitBytes } from "../session/log.js";
+import { loggingEnabled, listSessions, sessionCacheLimitBytes } from "../session/log.js";
 import { isTrusted } from "../config/trust.js";
-import { DEFAULT_DENY_PATTERNS, loopExemptTools } from "../agent/guards.js";
+import { DEFAULT_DENY_PATTERNS } from "../agent/guards.js";
 import { toolOutputLimit } from "../agent/limits.js";
-import { compactionConfigFromEnv, heapExceeded } from "../agent/compaction.js";
-import { shellPoolStats } from "../agent/shell-session.js";
-import { resolveToolProtocol, toolCapabilityKey } from "../agent/protocol-mode.js";
-import { getModelMeta, modelMetaOverridePath } from "./model-meta.js";
 const NODE_REQUIRED = "18.17";
 function readVersion() {
     return readPackageMeta().version;
@@ -61,16 +55,6 @@ export function collectDiagnostics() {
         // Same for plugins.
     }
     const platform = detectPlatform();
-    const compaction = compactionConfigFromEnv();
-    const shells = shellPoolStats();
-    let authMode = "missing";
-    try {
-        if (paths?.auth && existsSync(paths.auth))
-            authMode = (statSync(paths.auth).mode & 0o777).toString(8).padStart(4, "0");
-    }
-    catch {
-        authMode = "unreadable";
-    }
     return {
         version: readVersion(),
         node: process.version,
@@ -85,10 +69,6 @@ export function collectDiagnostics() {
         configRoot: paths?.root,
         configFile: paths?.config,
         authFile: paths?.auth,
-        authMode,
-        tmpdir: process.env["TMPDIR"] || osTmpdir(),
-        memTotalMb: totalmem() / 1024 / 1024,
-        memFreeMb: freemem() / 1024 / 1024,
         providerId: config.providerId,
         model: config.model,
         keyPresent,
@@ -100,8 +80,6 @@ export function collectDiagnostics() {
         enabledPlugins: (config.enabledPlugins ?? []).length,
         sessionLogEnabled: loggingEnabled(),
         sessionCacheMb: Math.round(sessionCacheLimitBytes() / (1024 * 1024)),
-        sessionFsync: fsyncMode(),
-        unclosedSessions: findUnclosedSessions().length,
         sessionsDir: paths?.sessions,
         sessionsCount: listSessions().length,
         sessionsBytes: listSessions().reduce((sum, entry) => sum + entry.bytes, 0),
@@ -110,25 +88,6 @@ export function collectDiagnostics() {
         shellDenyPatterns: DEFAULT_DENY_PATTERNS.length,
         allowDangerous: ["1", "true", "yes", "on"].includes((process.env["FASTCODE_ALLOW_DANGEROUS"] ?? "").trim().toLowerCase()),
         toolOutputLimit: toolOutputLimit(),
-        tokenBudget: positiveEnv("FASTCODE_TOKEN_BUDGET"),
-        costBudgetUsd: positiveEnv("FASTCODE_COST_BUDGET_USD"),
-        compactionEnabled: compaction.enabled,
-        compactionRatio: compaction.localThresholdRatio,
-        compactionHeapMb: compaction.heapLimitMb,
-        compactionHeapUsedMb: process.memoryUsage().heapUsed / 1024 / 1024,
-        compactionForced: heapExceeded(compaction),
-        serverCompactionAware: compaction.serverCompactionAware,
-        shellActive: shells.active,
-        shellPool: shells.pool,
-        shellSpawns: shells.spawns,
-        shellMaxSpawn: shells.maxSpawnPerTurn,
-        sseIdleMs: positiveEnv("FASTCODE_SSE_IDLE_MS") || 25_000,
-        toolProtocol: resolveToolProtocol(config, config.providerId, config.model),
-        toolProtocolMode: (process.env["FASTCODE_TOOL_PROTOCOL"] ?? "legacy").trim().toLowerCase(),
-        toolCapability: config.capabilities?.toolCalling?.[toolCapabilityKey(config.providerId, config.model)] ?? "unknown",
-        loopExempt: Array.from(loopExemptTools()),
-        modelMetaFile: modelMetaOverridePath(),
-        modelMeta: getModelMeta(config.providerId, config.model),
         providers: PROVIDERS.map((p) => ({
             id: p.id,
             label: p.label,
@@ -137,10 +96,6 @@ export function collectDiagnostics() {
         })),
     };
 }
-function positiveEnv(name) {
-    const value = Number(process.env[name]);
-    return Number.isFinite(value) && value > 0 ? value : 0;
-}
 export function formatDiagnostics(info) {
     const lines = [];
     lines.push(`FastCode ${info.version} — environment check`);
@@ -151,21 +106,12 @@ export function formatDiagnostics(info) {
     lines.push(`  stable UI     ${info.stableUi ? "on (anti-flicker)" : "off"}`);
     lines.push("  config root   " + (info.configRoot ?? "(unavailable)"));
     lines.push("  config file   " + (info.configFile ?? "(unavailable)"));
-    lines.push("  keys file     " + (info.authFile ?? "(unavailable)") + "   mode " + info.authMode + (info.authMode !== "missing" && info.authMode !== "0600" ? "  [WARN: expected 0600]" : ""));
-    lines.push("  tmpdir        " + info.tmpdir + (info.termux && !String(info.tmpdir).startsWith("/data/data/com.termux") ? "  [WARN: use $PREFIX/tmp]" : ""));
-    lines.push("  memory        " + info.memFreeMb.toFixed(0) + "MB free / " + info.memTotalMb.toFixed(0) + "MB total");
+    lines.push("  keys file     " + (info.authFile ?? "(unavailable)") + "   (separate, chmod 0600)");
     lines.push("  trusted cwd   " + (info.trusted ? "yes" : "NO - agent tools ask first or stay off") + "   (" + (info.trustFile ?? "?") + ")");
     lines.push("  session log   " + (info.sessionLogEnabled ? "on" : "off") + "   cache cap " + info.sessionCacheMb + "MB, " + info.sessionsCount + " file(s), " + (info.sessionsBytes / 1024 / 1024).toFixed(2) + "MB used");
-    lines.push("  session fsync " + info.sessionFsync + "   unclosed " + info.unclosedSessions + "   " + (info.sessionsDir ?? "(unavailable)"));
+    lines.push("  session dir   " + (info.sessionsDir ?? "(unavailable)"));
     lines.push("  shell guard   " + info.shellDenyPatterns + " deny patterns" + (info.allowDangerous ? "   [FASTCODE_ALLOW_DANGEROUS is ON]" : ""));
     lines.push("  tool output   " + info.toolOutputLimit + " chars max (streaming cap)");
-    lines.push(`  budgets       ${info.tokenBudget > 0 ? "tokens ≤ " + info.tokenBudget : "token budget off"} · ${info.costBudgetUsd > 0 ? "$" + info.costBudgetUsd : "cost budget off"}`);
-    lines.push(`  compaction    ${info.compactionEnabled ? "on" : "off"} · ${Math.round(info.compactionRatio * 100)}% · heap ${info.compactionHeapUsedMb.toFixed(1)}/${info.compactionHeapMb}MB${info.compactionForced ? " [FORCED]" : ""}${info.serverCompactionAware ? " · server-aware" : ""}`);
-    lines.push(`  shell pool    ${info.shellActive} active · ${info.shellPool} resident · ${info.shellSpawns} spawns · cap ${info.shellMaxSpawn}/turn`);
-    lines.push(`  loop exempt   ${info.loopExempt.length > 0 ? info.loopExempt.join(", ") : "(none)"}`);
-    lines.push(`  model meta    ctx ${info.modelMeta.contextWindow} · ~${info.modelMeta.charsPerToken} chars/token · ${info.modelMeta.supportsTools ? "tools" : "no tools"} · ${info.modelMetaFile}`);
-    lines.push(`  sse timeout   ${info.sseIdleMs}ms idle`);
-    lines.push(`  tool protocol ${info.toolProtocol} (${info.toolProtocolMode}) · cached ${info.toolCapability}`);
     lines.push(`  provider      ${info.providerId} · model ${info.model}`);
     let apiKeyStatus;
     if (info.keyPresent)
@@ -188,8 +134,6 @@ export function formatDiagnostics(info) {
         lines.push("    - pkg install nodejs git");
         lines.push("    - keep the session alive with: termux-wake-lock");
         lines.push("    - add an extra-keys row for Esc/Ctrl in ~/.termux/termux.properties");
-        lines.push("    - long tasks: export TMPDIR=$PREFIX/tmp and use termux-wake-lock");
-        lines.push(`    - Android 12+ caps phantom processes (~32); background shells are pooled (${info.shellPool} resident, cap ${info.shellMaxSpawn}/turn)`);
     }
     return lines.join("\n");
 }

package/src/lib/http.ts

@@ -16,21 +16,8 @@ export async function fetchJson(url: string, init: any = {}): Promise<any> {
     }
     return (await res.json());
 }
-export class NetworkStallError extends Error {
-    readonly code = "NETWORK_STALL";
-    readonly bytesReceived: number;
-    constructor(message: string, bytesReceived = 0) {
-        super(message);
-        this.name = "NetworkStallError";
-        this.bytesReceived = bytesReceived;
-    }
-}
-export interface StreamSseOptions {
-    idleTimeoutMs?: number;
-    totalTimeoutMs?: number;
-}
 /** Async iterator over SSE events from a streaming HTTP response. */
-export async function* streamSSE(res, options: StreamSseOptions = {}) {
+export async function* streamSSE(res) {
     if (!res.ok) {
         const body = await res.text().catch(() => "");
         throw new Error(`${res.status} ${res.statusText}: ${body.slice(0, 500)}`);
@@ -39,50 +26,19 @@ export async function* streamSSE(res, options: StreamSseOptions = {}) {
         throw new Error("Empty response body");
     const reader = res.body.getReader();
     const decoder = new TextDecoder("utf-8");
-    const envIdle = Number(process.env["FASTCODE_SSE_IDLE_MS"]);
-    const idleMs = positive(options.idleTimeoutMs, positive(envIdle, 25_000));
-    const totalMs = positive(options.totalTimeoutMs, 0);
-    const startedAt = Date.now();
-    let bytesReceived = 0;
     let buffer = "";
     while (true) {
-        const remaining = totalMs > 0 ? totalMs - (Date.now() - startedAt) : Number.POSITIVE_INFINITY;
-        if (remaining <= 0)
-            throw new NetworkStallError(`SSE total timeout after ${totalMs}ms`, bytesReceived);
-        const boundedByTotal = remaining <= idleMs;
-        const waitMs = boundedByTotal ? Math.max(1, remaining) : idleMs;
-        let timer: ReturnType<typeof setTimeout> | undefined;
-        const timeout = new Promise<never>((_resolve, reject) => {
-            timer = setTimeout(() => {
-                reject(new NetworkStallError(boundedByTotal
-                    ? `SSE total timeout after ${totalMs}ms`
-                    : `SSE idle timeout after ${idleMs}ms (no data received; set FASTCODE_SSE_IDLE_MS to wait longer)`, bytesReceived));
-            }, waitMs);
-        });
-        let chunk;
-        try {
-            chunk = await Promise.race([reader.read(), timeout]);
-        }
-        catch (err) {
-            await reader.cancel().catch(() => undefined);
-            throw err;
-        }
-        finally {
-            if (timer)
-                clearTimeout(timer);
-        }
-        const { value, done } = chunk;
+        const { value, done } = await reader.read();
         if (done)
             break;
-        bytesReceived += value?.byteLength ?? 0;
         // Normalize CR/LF so both "\n\n" and "\r\n\r\n" frame separators
         // are detected, including a CR/LF split across two chunks.
         buffer = (buffer + decoder.decode(value, { stream: true })).replace(/\r\n?/g, "\n");
         let sep = buffer.indexOf("\n\n");
         while (sep !== -1) {
-            const chunkText = buffer.slice(0, sep);
+            const chunk = buffer.slice(0, sep);
             buffer = buffer.slice(sep + 2);
-            const ev = parseSseChunk(chunkText);
+            const ev = parseSseChunk(chunk);
             if (ev)
                 yield ev;
             sep = buffer.indexOf("\n\n");
@@ -96,24 +52,6 @@ export async function* streamSSE(res, options: StreamSseOptions = {}) {
             yield ev;
     }
 }
-export async function probeConnectivity(url: string, timeoutMs = 3000): Promise<boolean> {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), positive(timeoutMs, 3000));
-    try {
-        const res = await fetch(url, { signal: controller.signal });
-        await res.body?.cancel().catch(() => undefined);
-        return res.ok;
-    }
-    catch {
-        return false;
-    }
-    finally {
-        clearTimeout(timer);
-    }
-}
-function positive(value, fallback) {
-    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
-}
 function parseSseChunk(chunk) {
     let event;
     const dataLines = [];

package/src/providers/anthropic.ts

@@ -10,16 +10,12 @@ 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) {
@@ -49,7 +45,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: any = {
+        const body = {
             model: req.model,
             messages,
             ...(req.system ? { system: req.system } : {}),
@@ -57,14 +53,6 @@ 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

@@ -11,6 +11,5 @@ export const deepseekProvider = {
     baseUrl: BASE,
     defaultModel: "deepseek-v4-pro",
     listModels: (apiKey) => listModelsHttp({ baseUrl: BASE, apiKey, staticModels: STATIC }),
-    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC, reasoning: "openai" }),
-    supportsReasoning: () => true,
+    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC }),
 };

package/src/providers/groq.ts

@@ -16,6 +16,5 @@ 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, reasoning: "openai" }),
-    supportsReasoning: () => true,
+    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC }),
 };

package/src/providers/index.ts

@@ -11,8 +11,7 @@ import { moonshotProvider } from "./moonshot.js";
 import { zhipuProvider } from "./zhipu.js";
 import { qwenProvider } from "./qwen.js";
 import { customProvider } from "./custom.js";
-import type { Provider } from "../types.js";
-export const PROVIDERS: Provider[] = [
+export const PROVIDERS = [
     anthropicProvider,
     openaiProvider,
     googleProvider,
@@ -36,33 +35,3 @@ 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,6 +15,5 @@ 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, reasoning: "openai" }),
-    supportsReasoning: () => true,
+    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC }),
 };

package/src/providers/moonshot.ts

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

package/src/providers/openai.ts

@@ -21,6 +21,5 @@ 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, reasoning: "openai" }),
-    supportsReasoning: (model) => /^(o\d|gpt-5|gpt-6)/i.test(model),
+    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC }),
 };