@datename/fastcode-termux 0.0.0-stage → 0.1.6

package/dist/providers/index.js

@@ -0,0 +1,37 @@
+import { anthropicProvider } from "./anthropic.js";
+import { openaiProvider } from "./openai.js";
+import { googleProvider } from "./google.js";
+import { openrouterProvider } from "./openrouter.js";
+import { groqProvider } from "./groq.js";
+import { deepseekProvider } from "./deepseek.js";
+import { mistralProvider } from "./mistral.js";
+import { ollamaProvider } from "./ollama.js";
+import { xaiProvider } from "./xai.js";
+import { moonshotProvider } from "./moonshot.js";
+import { zhipuProvider } from "./zhipu.js";
+import { qwenProvider } from "./qwen.js";
+import { customProvider } from "./custom.js";
+export const PROVIDERS = [
+    anthropicProvider,
+    openaiProvider,
+    googleProvider,
+    deepseekProvider,
+    openrouterProvider,
+    groqProvider,
+    mistralProvider,
+    xaiProvider,
+    moonshotProvider,
+    zhipuProvider,
+    qwenProvider,
+    ollamaProvider,
+    customProvider,
+];
+export function getProvider(id) {
+    return PROVIDERS.find((p) => p.id === id);
+}
+export function getProviderOrThrow(id) {
+    const p = getProvider(id);
+    if (!p)
+        throw new Error("Unknown provider: " + id);
+    return p;
+}

package/dist/providers/mistral.d.ts

@@ -0,0 +1,24 @@
+export declare const mistralProvider: {
+    id: string;
+    label: string;
+    authEnv: string[];
+    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>;
+};

package/dist/providers/mistral.js

@@ -0,0 +1,19 @@
+import { listModelsHttp, streamChatCompletion } from "./openaiCompatible.js";
+const BASE = "https://api.mistral.ai/v1";
+const STATIC = [
+    { id: "mistral-large-latest", label: "Mistral Large" },
+    { id: "mistral-medium-latest", label: "Mistral Medium" },
+    { id: "mistral-small-latest", label: "Mistral Small" },
+    { id: "codestral-latest", label: "Codestral" },
+    { id: "devstral-medium-latest", label: "Devstral" },
+    { id: "magistral-medium-latest", label: "Magistral" },
+];
+export const mistralProvider = {
+    id: "mistral",
+    label: "Mistral",
+    authEnv: ["MISTRAL_API_KEY"],
+    baseUrl: BASE,
+    defaultModel: "mistral-small-latest",
+    listModels: (apiKey) => listModelsHttp({ baseUrl: BASE, apiKey, staticModels: STATIC }),
+    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC }),
+};

package/dist/providers/moonshot.d.ts

@@ -0,0 +1,24 @@
+export declare const moonshotProvider: {
+    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>;
+};

package/dist/providers/moonshot.js

@@ -0,0 +1,22 @@
+import { listModelsHttp, streamChatCompletion } from "./openaiCompatible.js";
+function baseUrl() {
+    return (process.env["MOONSHOT_BASE_URL"] ?? "").trim() || "https://api.moonshot.cn/v1";
+}
+const STATIC = [
+    { id: "kimi-k3", label: "Kimi K3" },
+    { id: "kimi-k2.7-code", label: "Kimi K2.7 Code" },
+    { id: "kimi-k2.6", label: "Kimi K2.6" },
+    { id: "kimi-k2-thinking", label: "Kimi K2 Thinking" },
+    { id: "kimi-k2-0905", label: "Kimi K2 0905" },
+];
+export const moonshotProvider = {
+    id: "moonshot",
+    label: "Moonshot (Kimi)",
+    authEnv: ["MOONSHOT_API_KEY"],
+    get baseUrl() {
+        return baseUrl();
+    },
+    defaultModel: "kimi-k3",
+    listModels: (apiKey) => listModelsHttp({ baseUrl: baseUrl(), apiKey, staticModels: STATIC }),
+    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: baseUrl(), apiKey, staticModels: STATIC }),
+};

package/dist/providers/ollama.d.ts

@@ -0,0 +1,24 @@
+export declare const ollamaProvider: {
+    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/ollama.js

@@ -0,0 +1,22 @@
+import { listModelsHttp, streamChatCompletion } from "./openaiCompatible.js";
+function baseUrl() {
+    const host = (process.env["OLLAMA_HOST"] ?? "").trim() || "http://localhost:11434";
+    return host.endsWith("/v1") ? host : host + "/v1";
+}
+const STATIC = [
+    { id: "qwen3-coder", label: "qwen3-coder (local)" },
+    { id: "llama3.2", label: "llama3.2 (local)" },
+    { id: "gpt-oss", label: "gpt-oss (local)" },
+    { id: "deepseek-r1", label: "deepseek-r1 (local)" },
+];
+export const ollamaProvider = {
+    id: "ollama",
+    label: "Ollama (local)",
+    authEnv: [],
+    get baseUrl() {
+        return baseUrl();
+    },
+    defaultModel: "qwen3-coder",
+    listModels: () => listModelsHttp({ baseUrl: baseUrl(), apiKey: undefined, staticModels: STATIC }),
+    stream: (req) => streamChatCompletion(req, { baseUrl: baseUrl(), apiKey: undefined, staticModels: STATIC }),
+};

package/dist/providers/openai.d.ts

@@ -0,0 +1,24 @@
+export declare const openaiProvider: {
+    id: string;
+    label: string;
+    authEnv: string[];
+    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>;
+};

package/dist/providers/openai.js

@@ -0,0 +1,25 @@
+import { listModelsHttp, streamChatCompletion } from "./openaiCompatible.js";
+const BASE = "https://api.openai.com/v1";
+const STATIC = [
+    { id: "gpt-6.1-sol", label: "GPT-6.1 Sol" },
+    { id: "gpt-6.1-sol-pro", label: "GPT-6.1 Sol Pro" },
+    { id: "gpt-6-luna", label: "GPT-6 Luna" },
+    { id: "gpt-6-luna-pro", label: "GPT-6 Luna Pro" },
+    { id: "gpt-6-sol", label: "GPT-6 Sol" },
+    { id: "gpt-5.6-terra", label: "GPT-5.6 Terra" },
+    { id: "gpt-5.6-luna", label: "GPT-5.6 Luna" },
+    { id: "gpt-4.1", label: "GPT-4.1", pricing: { inputUsdPerM: 2, outputUsdPerM: 8 } },
+    { id: "gpt-4o", label: "GPT-4o", pricing: { inputUsdPerM: 2.5, outputUsdPerM: 10 } },
+    { id: "gpt-4o-mini", label: "GPT-4o mini", pricing: { inputUsdPerM: 0.15, outputUsdPerM: 0.6 } },
+    { id: "o4-mini", label: "o4-mini" },
+    { id: "o3", label: "o3" },
+];
+export const openaiProvider = {
+    id: "openai",
+    label: "OpenAI",
+    authEnv: ["OPENAI_API_KEY"],
+    baseUrl: BASE,
+    defaultModel: "gpt-6-luna",
+    listModels: (apiKey) => listModelsHttp({ baseUrl: BASE, apiKey, staticModels: STATIC }),
+    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC }),
+};

package/dist/providers/openaiCompatible.d.ts

@@ -0,0 +1,17 @@
+export declare function streamChatCompletion(req: any, opts: 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 listModelsHttp(opts: any): Promise<any>;

package/dist/providers/openaiCompatible.js

@@ -0,0 +1,110 @@
+import { fetchJson, streamSSE } from "../lib/http.js";
+/** Build a chat-completions body in the classic or the newer (compat) dialect. */
+function buildBody(req, compat) {
+    const messages = [];
+    if (req.system)
+        messages.push({ role: "system", content: req.system });
+    for (const m of req.messages)
+        messages.push({ role: m.role, content: m.content });
+    const body = { model: req.model, messages, stream: true };
+    if (req.maxOutputTokens !== undefined) {
+        if (compat)
+            body.max_completion_tokens = req.maxOutputTokens;
+        else
+            body.max_tokens = req.maxOutputTokens;
+    }
+    if (req.temperature !== undefined && !compat)
+        body.temperature = req.temperature;
+    return body;
+}
+export async function* streamChatCompletion(req, opts) {
+    const send = async (compat) => {
+        const headers = {
+            "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", {
+            method: "POST",
+            headers,
+            body: JSON.stringify(buildBody(req, compat)),
+            signal: req.signal,
+        });
+    };
+    let res = await send(false);
+    if (!res.ok) {
+        const 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) {
+            const body = await res.text().catch(() => "");
+            throw new Error(res.status + " " + res.statusText + ": " + body.slice(0, 500));
+        }
+    }
+    let usage;
+    for await (const ev of streamSSE(res)) {
+        if (ev.data === "[DONE]")
+            break;
+        let payload;
+        try {
+            payload = JSON.parse(ev.data);
+        }
+        catch {
+            continue;
+        }
+        const obj = payload;
+        const choice = obj.choices?.[0];
+        const raw = choice?.delta?.content ?? choice?.text;
+        const reasoning = choice?.delta?.reasoning_content ?? choice?.delta?.reasoning;
+        if (obj.usage) {
+            usage = {
+                inputTokens: obj.usage.prompt_tokens,
+                outputTokens: obj.usage.completion_tokens,
+                totalTokens: obj.usage.total_tokens,
+            };
+        }
+        const text = typeof raw === "string"
+            ? raw
+            : Array.isArray(raw)
+                ? raw.map((part) => (part?.text ?? "")).join("")
+                : "";
+        if (text)
+            yield { delta: text, done: false };
+        else if (typeof reasoning === "string" && reasoning)
+            yield { delta: "", done: false, reasoning };
+    }
+    yield { delta: "", done: true, usage };
+}
+export async function listModelsHttp(opts) {
+    const staticModels = opts.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 ids = (json.data ?? [])
+            .map((m) => m.id)
+            .filter((id) => typeof id === "string" && id.length > 0);
+        if (ids.length === 0)
+            return staticModels;
+        // The provider's live list is authoritative: show exactly what it
+        // returns (enriched with our labels/pricing where the id is known).
+        // Static models the provider no longer returns are dropped so delisted
+        // models don't linger in the picker.
+        const known = new Map(staticModels.map((m) => [m.id, m]));
+        return ids.map((id) => known.get(id) ?? { id });
+    }
+    catch {
+        return staticModels;
+    }
+}
+function trim(url) {
+    return url.replace(/[/]+$/, "");
+}

package/dist/providers/openrouter.d.ts

@@ -0,0 +1,24 @@
+export declare const openrouterProvider: {
+    id: string;
+    label: string;
+    authEnv: string[];
+    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>;
+};

package/dist/providers/openrouter.js

@@ -0,0 +1,26 @@
+import { listModelsHttp, streamChatCompletion } from "./openaiCompatible.js";
+const BASE = "https://openrouter.ai/api/v1";
+const STATIC = [
+    { id: "anthropic/claude-sonnet-5.5", label: "Claude Sonnet 5.5" },
+    { id: "openai/gpt-6-luna", label: "GPT-6 Luna" },
+    { id: "google/gemini-3.8-flash", label: "Gemini 3.8 Flash" },
+    { id: "deepseek/deepseek-v4-pro", label: "DeepSeek V4 Pro" },
+    { id: "x-ai/grok-4.7", label: "Grok 4.7" },
+    { id: "moonshotai/kimi-k3", label: "Kimi K3" },
+    { id: "z-ai/glm-5.3", label: "GLM 5.3" },
+    { id: "qwen/qwen3.8-max", label: "Qwen3.8 Max" },
+    { id: "meta-llama/llama-4-maverick", label: "Llama 4 Maverick" },
+];
+const EXTRA_HEADERS = {
+    "http-referer": "https://github.com/dateName/fastcode-termux",
+    "x-title": "FastCode",
+};
+export const openrouterProvider = {
+    id: "openrouter",
+    label: "OpenRouter (400+ models)",
+    authEnv: ["OPENROUTER_API_KEY"],
+    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 }),
+};

package/dist/providers/qwen.d.ts

@@ -0,0 +1,24 @@
+export declare const qwenProvider: {
+    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>;
+};

package/dist/providers/qwen.js

@@ -0,0 +1,23 @@
+import { listModelsHttp, streamChatCompletion } from "./openaiCompatible.js";
+function baseUrl() {
+    return (process.env["DASHSCOPE_BASE_URL"] ?? "").trim() || "https://dashscope.aliyuncs.com/compatible-mode/v1";
+}
+const STATIC = [
+    { id: "qwen3.8-max", label: "Qwen3.8 Max" },
+    { id: "qwen3.8-flash", label: "Qwen3.8 Flash" },
+    { id: "qwen3.7-max", label: "Qwen3.7 Max" },
+    { id: "qwen3.7-plus", label: "Qwen3.7 Plus" },
+    { id: "qwen3-coder-next", label: "Qwen3 Coder Next" },
+    { id: "qwen3.6-27b", label: "Qwen3.6 27B" },
+];
+export const qwenProvider = {
+    id: "qwen",
+    label: "Qwen (DashScope)",
+    authEnv: ["DASHSCOPE_API_KEY", "QWEN_API_KEY"],
+    get baseUrl() {
+        return baseUrl();
+    },
+    defaultModel: "qwen3.8-max",
+    listModels: (apiKey) => listModelsHttp({ baseUrl: baseUrl(), apiKey, staticModels: STATIC }),
+    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: baseUrl(), apiKey, staticModels: STATIC }),
+};

package/dist/providers/xai.d.ts

@@ -0,0 +1,24 @@
+export declare const xaiProvider: {
+    id: string;
+    label: string;
+    authEnv: string[];
+    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>;
+};

package/dist/providers/xai.js

@@ -0,0 +1,18 @@
+import { listModelsHttp, streamChatCompletion } from "./openaiCompatible.js";
+const BASE = "https://api.x.ai/v1";
+const STATIC = [
+    { id: "grok-4.7", label: "Grok 4.7" },
+    { id: "grok-4.6", label: "Grok 4.6" },
+    { id: "grok-4.5", label: "Grok 4.5" },
+    { id: "grok-4.3", label: "Grok 4.3" },
+    { id: "grok-4.20", label: "Grok 4.20" },
+];
+export const xaiProvider = {
+    id: "xai",
+    label: "xAI (Grok)",
+    authEnv: ["XAI_API_KEY", "GROK_API_KEY"],
+    baseUrl: BASE,
+    defaultModel: "grok-4.7",
+    listModels: (apiKey) => listModelsHttp({ baseUrl: BASE, apiKey, staticModels: STATIC }),
+    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC }),
+};

package/dist/providers/zhipu.d.ts

@@ -0,0 +1,24 @@
+export declare const zhipuProvider: {
+    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>;
+};

package/dist/providers/zhipu.js

@@ -0,0 +1,23 @@
+import { listModelsHttp, streamChatCompletion } from "./openaiCompatible.js";
+function baseUrl() {
+    return (process.env["ZHIPU_BASE_URL"] ?? "").trim() || "https://open.bigmodel.cn/api/paas/v4";
+}
+const STATIC = [
+    { id: "glm-5.3", label: "GLM 5.3" },
+    { id: "glm-5.2", label: "GLM 5.2" },
+    { id: "glm-5.1", label: "GLM 5.1" },
+    { id: "glm-5", label: "GLM 5" },
+    { id: "glm-4.7", label: "GLM 4.7" },
+    { id: "glm-4.6", label: "GLM 4.6" },
+];
+export const zhipuProvider = {
+    id: "zhipu",
+    label: "Zhipu (GLM)",
+    authEnv: ["ZHIPUAI_API_KEY", "GLM_API_KEY", "ZHIPU_API_KEY"],
+    get baseUrl() {
+        return baseUrl();
+    },
+    defaultModel: "glm-5.3",
+    listModels: (apiKey) => listModelsHttp({ baseUrl: baseUrl(), apiKey, staticModels: STATIC }),
+    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: baseUrl(), apiKey, staticModels: STATIC }),
+};

package/dist/session/log.d.ts

@@ -0,0 +1,29 @@
+export declare function sessionCacheLimitBytes(): number;
+export declare function loggingEnabled(): boolean;
+export declare function createSessionLog(meta?: {}): {
+    id: any;
+    file: any;
+    append: (entry: any) => void;
+    close(): void;
+};
+export declare function openSessionLog(file: any): {
+    id: any;
+    file: any;
+    append: (entry: any) => void;
+    close(): void;
+};
+export declare function listSessions(): {
+    id: string;
+    file: string;
+    bytes: number;
+    modified: string;
+    messages: number;
+}[];
+export declare function resolveSessionFile(idOrFile: any): any;
+export declare function readSession(idOrFile: any): any[];
+export declare function loadSessionMessages(idOrFile: any): {
+    role: any;
+    content: any;
+}[];
+export declare function latestSessionFile(): string;
+export declare function pruneSessions(limit?: number): number;