@datename/fastcode-termux 0.1.6-beta → 0.1.6

package/dist/lib/http.js

@@ -16,17 +16,8 @@ export async function fetchJson(url, init = {}) {
     }
     return (await res.json());
 }
-export class NetworkStallError extends Error {
-    code = "NETWORK_STALL";
-    bytesReceived;
-    constructor(message, bytesReceived = 0) {
-        super(message);
-        this.name = "NetworkStallError";
-        this.bytesReceived = bytesReceived;
-    }
-}
 /** Async iterator over SSE events from a streaming HTTP response. */
-export async function* streamSSE(res, options = {}) {
+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)}`);
@@ -35,50 +26,19 @@ export async function* streamSSE(res, options = {}) {
         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;
-        const timeout = new Promise((_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");
@@ -92,24 +52,6 @@ export async function* streamSSE(res, options = {}) {
             yield ev;
     }
 }
-export async function probeConnectivity(url, timeoutMs = 3000) {
-    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/dist/providers/anthropic.d.ts

@@ -4,7 +4,6 @@ export declare const anthropicProvider: {
     authEnv: string[];
     baseUrl: string;
     defaultModel: string;
-    supportsReasoning(): boolean;
     listModels(apiKey: any): Promise<any>;
     stream(req: any, apiKey: any): AsyncGenerator<{
         delta: any;

package/dist/providers/anthropic.js

@@ -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) {
@@ -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/dist/providers/custom.d.ts

@@ -10,24 +10,15 @@ export declare const customProvider: {
         done: boolean;
         reasoning?: undefined;
         usage?: undefined;
-        toolCalls?: undefined;
     } | {
         delta: string;
         done: boolean;
         reasoning: string;
         usage?: undefined;
-        toolCalls?: undefined;
     } | {
         delta: string;
         done: boolean;
         usage: any;
-        toolCalls: import("../types.js").NativeToolCall[];
         reasoning?: undefined;
-    } | {
-        delta: string;
-        done: boolean;
-        usage: any;
-        reasoning?: undefined;
-        toolCalls?: undefined;
     }, void, unknown>;
 };

package/dist/providers/deepseek.d.ts

@@ -10,25 +10,15 @@ export declare const deepseekProvider: {
         done: boolean;
         reasoning?: undefined;
         usage?: undefined;
-        toolCalls?: undefined;
     } | {
         delta: string;
         done: boolean;
         reasoning: string;
         usage?: undefined;
-        toolCalls?: undefined;
     } | {
         delta: string;
         done: boolean;
         usage: any;
-        toolCalls: import("../types.js").NativeToolCall[];
         reasoning?: undefined;
-    } | {
-        delta: string;
-        done: boolean;
-        usage: any;
-        reasoning?: undefined;
-        toolCalls?: undefined;
     }, void, unknown>;
-    supportsReasoning: () => boolean;
 };

package/dist/providers/deepseek.js

@@ -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/dist/providers/google.d.ts

@@ -10,24 +10,15 @@ export declare const googleProvider: {
         done: boolean;
         reasoning?: undefined;
         usage?: undefined;
-        toolCalls?: undefined;
     } | {
         delta: string;
         done: boolean;
         reasoning: string;
         usage?: undefined;
-        toolCalls?: undefined;
     } | {
         delta: string;
         done: boolean;
         usage: any;
-        toolCalls: import("../types.js").NativeToolCall[];
         reasoning?: undefined;
-    } | {
-        delta: string;
-        done: boolean;
-        usage: any;
-        reasoning?: undefined;
-        toolCalls?: undefined;
     }, void, unknown>;
 };

package/dist/providers/groq.d.ts

@@ -10,25 +10,15 @@ export declare const groqProvider: {
         done: boolean;
         reasoning?: undefined;
         usage?: undefined;
-        toolCalls?: undefined;
     } | {
         delta: string;
         done: boolean;
         reasoning: string;
         usage?: undefined;
-        toolCalls?: undefined;
     } | {
         delta: string;
         done: boolean;
         usage: any;
-        toolCalls: import("../types.js").NativeToolCall[];
         reasoning?: undefined;
-    } | {
-        delta: string;
-        done: boolean;
-        usage: any;
-        reasoning?: undefined;
-        toolCalls?: undefined;
     }, void, unknown>;
-    supportsReasoning: () => boolean;
 };

package/dist/providers/groq.js

@@ -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/dist/providers/index.d.ts

@@ -1,10 +1,201 @@
-import type { Provider } from "../types.js";
-export declare const PROVIDERS: Provider[];
-export declare function getProvider(id: any): Provider;
-export declare function getProviderOrThrow(id: any): Provider;
-/**
- * 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 declare function probeProvider(provider: any, apiKey: any, timeoutMs?: number): Promise<boolean>;
+export declare const PROVIDERS: ({
+    id: string;
+    label: string;
+    authEnv: string[];
+    baseUrl: string;
+    defaultModel: string;
+    listModels(apiKey: any): Promise<any>;
+    stream(req: any, apiKey: any): AsyncGenerator<{
+        delta: any;
+        done: boolean;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        usage: {
+            inputTokens: number;
+            outputTokens: number;
+            costUsd: number;
+        };
+    }, void, unknown>;
+} | {
+    id: string;
+    label: string;
+    authEnv: string[];
+    readonly baseUrl: string;
+    defaultModel: string;
+    listModels: (apiKey: any) => Promise<any>;
+    stream: (req: any, apiKey: any) => AsyncGenerator<{
+        delta: string;
+        done: boolean;
+        reasoning?: undefined;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        reasoning: string;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        usage: any;
+        reasoning?: undefined;
+    }, void, unknown>;
+} | {
+    id: string;
+    label: string;
+    authEnv: any[];
+    readonly baseUrl: string;
+    defaultModel: string;
+    listModels: () => Promise<any>;
+    stream: (req: any) => AsyncGenerator<{
+        delta: string;
+        done: boolean;
+        reasoning?: undefined;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        reasoning: string;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        usage: any;
+        reasoning?: undefined;
+    }, void, unknown>;
+})[];
+export declare function getProvider(id: any): {
+    id: string;
+    label: string;
+    authEnv: string[];
+    baseUrl: string;
+    defaultModel: string;
+    listModels(apiKey: any): Promise<any>;
+    stream(req: any, apiKey: any): AsyncGenerator<{
+        delta: any;
+        done: boolean;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        usage: {
+            inputTokens: number;
+            outputTokens: number;
+            costUsd: number;
+        };
+    }, void, unknown>;
+} | {
+    id: string;
+    label: string;
+    authEnv: string[];
+    readonly baseUrl: string;
+    defaultModel: string;
+    listModels: (apiKey: any) => Promise<any>;
+    stream: (req: any, apiKey: any) => AsyncGenerator<{
+        delta: string;
+        done: boolean;
+        reasoning?: undefined;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        reasoning: string;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        usage: any;
+        reasoning?: undefined;
+    }, void, unknown>;
+} | {
+    id: string;
+    label: string;
+    authEnv: any[];
+    readonly baseUrl: string;
+    defaultModel: string;
+    listModels: () => Promise<any>;
+    stream: (req: any) => AsyncGenerator<{
+        delta: string;
+        done: boolean;
+        reasoning?: undefined;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        reasoning: string;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        usage: any;
+        reasoning?: undefined;
+    }, void, unknown>;
+};
+export declare function getProviderOrThrow(id: any): {
+    id: string;
+    label: string;
+    authEnv: string[];
+    baseUrl: string;
+    defaultModel: string;
+    listModels(apiKey: any): Promise<any>;
+    stream(req: any, apiKey: any): AsyncGenerator<{
+        delta: any;
+        done: boolean;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        usage: {
+            inputTokens: number;
+            outputTokens: number;
+            costUsd: number;
+        };
+    }, void, unknown>;
+} | {
+    id: string;
+    label: string;
+    authEnv: string[];
+    readonly baseUrl: string;
+    defaultModel: string;
+    listModels: (apiKey: any) => Promise<any>;
+    stream: (req: any, apiKey: any) => AsyncGenerator<{
+        delta: string;
+        done: boolean;
+        reasoning?: undefined;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        reasoning: string;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        usage: any;
+        reasoning?: undefined;
+    }, void, unknown>;
+} | {
+    id: string;
+    label: string;
+    authEnv: any[];
+    readonly baseUrl: string;
+    defaultModel: string;
+    listModels: () => Promise<any>;
+    stream: (req: any) => AsyncGenerator<{
+        delta: string;
+        done: boolean;
+        reasoning?: undefined;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        reasoning: string;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        usage: any;
+        reasoning?: undefined;
+    }, void, unknown>;
+};

package/dist/providers/index.js

@@ -35,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/dist/providers/mistral.d.ts

@@ -10,25 +10,15 @@ export declare const mistralProvider: {
         done: boolean;
         reasoning?: undefined;
         usage?: undefined;
-        toolCalls?: undefined;
     } | {
         delta: string;
         done: boolean;
         reasoning: string;
         usage?: undefined;
-        toolCalls?: undefined;
     } | {
         delta: string;
         done: boolean;
         usage: any;
-        toolCalls: import("../types.js").NativeToolCall[];
         reasoning?: undefined;
-    } | {
-        delta: string;
-        done: boolean;
-        usage: any;
-        reasoning?: undefined;
-        toolCalls?: undefined;
     }, void, unknown>;
-    supportsReasoning: () => boolean;
 };

package/dist/providers/mistral.js

@@ -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/dist/providers/moonshot.d.ts

@@ -10,25 +10,15 @@ export declare const moonshotProvider: {
         done: boolean;
         reasoning?: undefined;
         usage?: undefined;
-        toolCalls?: undefined;
     } | {
         delta: string;
         done: boolean;
         reasoning: string;
         usage?: undefined;
-        toolCalls?: undefined;
     } | {
         delta: string;
         done: boolean;
         usage: any;
-        toolCalls: import("../types.js").NativeToolCall[];
         reasoning?: undefined;
-    } | {
-        delta: string;
-        done: boolean;
-        usage: any;
-        reasoning?: undefined;
-        toolCalls?: undefined;
     }, void, unknown>;
-    supportsReasoning: () => boolean;
 };

package/dist/providers/moonshot.js

@@ -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/dist/providers/ollama.d.ts

@@ -10,24 +10,15 @@ export declare const ollamaProvider: {
         done: boolean;
         reasoning?: undefined;
         usage?: undefined;
-        toolCalls?: undefined;
     } | {
         delta: string;
         done: boolean;
         reasoning: string;
         usage?: undefined;
-        toolCalls?: undefined;
     } | {
         delta: string;
         done: boolean;
         usage: any;
-        toolCalls: import("../types.js").NativeToolCall[];
         reasoning?: undefined;
-    } | {
-        delta: string;
-        done: boolean;
-        usage: any;
-        reasoning?: undefined;
-        toolCalls?: undefined;
     }, void, unknown>;
 };

package/dist/providers/openai.d.ts

@@ -10,25 +10,15 @@ export declare const openaiProvider: {
         done: boolean;
         reasoning?: undefined;
         usage?: undefined;
-        toolCalls?: undefined;
     } | {
         delta: string;
         done: boolean;
         reasoning: string;
         usage?: undefined;
-        toolCalls?: undefined;
     } | {
         delta: string;
         done: boolean;
         usage: any;
-        toolCalls: import("../types.js").NativeToolCall[];
         reasoning?: undefined;
-    } | {
-        delta: string;
-        done: boolean;
-        usage: any;
-        reasoning?: undefined;
-        toolCalls?: undefined;
     }, void, unknown>;
-    supportsReasoning: (model: any) => boolean;
 };

package/dist/providers/openai.js

@@ -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 }),
 };

package/dist/providers/openaiCompatible.d.ts

@@ -3,24 +3,15 @@ export declare function streamChatCompletion(req: any, opts: any): AsyncGenerato
     done: boolean;
     reasoning?: undefined;
     usage?: undefined;
-    toolCalls?: undefined;
 } | {
     delta: string;
     done: boolean;
     reasoning: string;
     usage?: undefined;
-    toolCalls?: undefined;
 } | {
     delta: string;
     done: boolean;
     usage: any;
-    toolCalls: import("../types.js").NativeToolCall[];
     reasoning?: undefined;
-} | {
-    delta: string;
-    done: boolean;
-    usage: any;
-    reasoning?: undefined;
-    toolCalls?: undefined;
 }, void, unknown>;
 export declare function listModelsHttp(opts: any): Promise<any>;