@datename/fastcode-termux 0.0.0-stage → 0.1.6

package/src/providers/anthropic.ts

@@ -0,0 +1,107 @@
+import { streamSSE } from "../lib/http.js";
+const STATIC_MODELS = [
+    { id: "claude-sonnet-5.5", label: "Claude Sonnet 5.5", contextWindow: 1000000, pricing: { inputUsdPerM: 3, outputUsdPerM: 15 } },
+    { id: "claude-opus-5.5", label: "Claude Opus 5.5", contextWindow: 1000000, pricing: { inputUsdPerM: 15, outputUsdPerM: 75 } },
+    { id: "claude-haiku-5.5", label: "Claude Haiku 5.5", contextWindow: 200000, pricing: { inputUsdPerM: 0.8, outputUsdPerM: 4 } },
+    { id: "claude-sonnet-5", label: "Claude Sonnet 5" },
+    { id: "claude-opus-5", label: "Claude Opus 5" },
+    { id: "claude-sonnet-4.6", label: "Claude Sonnet 4.6" },
+    { id: "claude-opus-4.6", label: "Claude Opus 4.6" },
+    { id: "claude-haiku-4.5", label: "Claude Haiku 4.5" },
+];
+const BASE = "https://api.anthropic.com/v1";
+export const anthropicProvider = {
+    id: "anthropic",
+    label: "Anthropic (Claude)",
+    authEnv: ["ANTHROPIC_API_KEY", "CLAUDE_API_KEY"],
+    baseUrl: BASE,
+    defaultModel: "claude-sonnet-5.5",
+    async listModels(apiKey) {
+        // Query the live model list; fall back to the built-in list offline.
+        if (apiKey) {
+            try {
+                const res = await fetch(BASE + "/models", {
+                    headers: { "x-api-key": apiKey, "anthropic-version": "2023-06-01" },
+                });
+                if (res.ok) {
+                    const json: any = await res.json();
+                    const ids = (json.data ?? [])
+                        .map((m) => m.id)
+                        .filter((id) => typeof id === "string" && id.length > 0);
+                    if (ids.length > 0) {
+                        const known = new Map(STATIC_MODELS.map((m) => [m.id, m]));
+                        return ids.map((id) => known.get(id) ?? { id });
+                    }
+                }
+            }
+            catch {
+                // network/auth issue → fall through to the static list
+            }
+        }
+        return STATIC_MODELS;
+    },
+    async *stream(req, apiKey) {
+        if (!apiKey) {
+            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 = {
+            model: req.model,
+            messages,
+            ...(req.system ? { system: req.system } : {}),
+            stream: true,
+            max_tokens: req.maxOutputTokens ?? 4096,
+            ...(req.temperature !== undefined ? { temperature: req.temperature } : {}),
+        };
+        const res = await fetch(BASE + "/messages", {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "x-api-key": apiKey,
+                "anthropic-version": "2023-06-01",
+                accept: "text/event-stream",
+            },
+            body: JSON.stringify(body),
+            signal: req.signal,
+        });
+        let usageInput = 0;
+        let usageOutput = 0;
+        for await (const ev of streamSSE(res)) {
+            let data;
+            try {
+                data = JSON.parse(ev.data);
+            }
+            catch {
+                continue;
+            }
+            const t = data.type;
+            if (t === "content_block_delta") {
+                const delta = data.delta?.text;
+                if (delta)
+                    yield { delta, done: false };
+            }
+            else if (t === "message_start") {
+                const u = data.message?.usage;
+                if (u?.input_tokens)
+                    usageInput = u.input_tokens;
+            }
+            else if (t === "message_delta") {
+                const u = data.usage;
+                if (u?.output_tokens)
+                    usageOutput = u.output_tokens;
+            }
+            else if (t === "message_stop") {
+                break;
+            }
+        }
+        const cost = priceFor(req.model, usageInput, usageOutput);
+        yield { delta: "", done: true, usage: { inputTokens: usageInput, outputTokens: usageOutput, costUsd: cost } };
+    },
+};
+function priceFor(modelId, input, output) {
+    const m = STATIC_MODELS.find((x) => x.id === modelId);
+    const p = m?.pricing;
+    if (!p?.inputUsdPerM || !p.outputUsdPerM)
+        return undefined;
+    return (input / 1000000) * p.inputUsdPerM + (output / 1000000) * p.outputUsdPerM;
+}

package/src/providers/custom.ts

@@ -0,0 +1,25 @@
+import { listModelsHttp, streamChatCompletion } from "./openaiCompatible.js";
+function baseUrl() {
+    return (process.env["FASTCODE_BASE_URL"] ?? "").trim().replace(/[/]+$/, "");
+}
+function defaultModel() {
+    return (process.env["FASTCODE_MODEL"] ?? "").trim() || "gpt-4o-mini";
+}
+function requireBaseUrl() {
+    const base = baseUrl();
+    if (!base) {
+        throw new Error("FASTCODE_BASE_URL is not set. Example: export FASTCODE_BASE_URL=https://api.example.com/v1");
+    }
+    return base;
+}
+export const customProvider = {
+    id: "custom",
+    label: "Custom (OpenAI-compatible)",
+    authEnv: [],
+    get baseUrl() {
+        return baseUrl();
+    },
+    defaultModel: defaultModel(),
+    listModels: () => listModelsHttp({ baseUrl: requireBaseUrl(), apiKey: process.env["FASTCODE_API_KEY"], staticModels: [] }),
+    stream: (req) => streamChatCompletion(req, { baseUrl: requireBaseUrl(), apiKey: process.env["FASTCODE_API_KEY"], staticModels: [] }),
+};

package/src/providers/deepseek.ts

@@ -0,0 +1,15 @@
+import { listModelsHttp, streamChatCompletion } from "./openaiCompatible.js";
+const BASE = "https://api.deepseek.com/v1";
+const STATIC = [
+    { id: "deepseek-v4-pro", label: "DeepSeek V4 Pro" },
+    { id: "deepseek-flash", label: "DeepSeek Flash" },
+];
+export const deepseekProvider = {
+    id: "deepseek",
+    label: "DeepSeek",
+    authEnv: ["DEEPSEEK_API_KEY"],
+    baseUrl: BASE,
+    defaultModel: "deepseek-v4-pro",
+    listModels: (apiKey) => listModelsHttp({ baseUrl: BASE, apiKey, staticModels: STATIC }),
+    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC }),
+};

package/src/providers/google.ts

@@ -0,0 +1,19 @@
+import { listModelsHttp, streamChatCompletion } from "./openaiCompatible.js";
+const BASE = "https://generativelanguage.googleapis.com/v1beta/openai";
+const STATIC = [
+    { id: "gemini-3.8-flash", label: "Gemini 3.8 Flash" },
+    { id: "gemini-3.7-flash", label: "Gemini 3.7 Flash" },
+    { id: "gemini-3.5-flash", label: "Gemini 3.5 Flash" },
+    { id: "gemini-3.5-flash-lite", label: "Gemini 3.5 Flash Lite" },
+    { id: "gemini-3.1-flash-lite", label: "Gemini 3.1 Flash Lite" },
+    { id: "gemini-4-argon", label: "Gemini 4 Argon" },
+];
+export const googleProvider = {
+    id: "google",
+    label: "Google Gemini",
+    authEnv: ["GEMINI_API_KEY", "GOOGLE_API_KEY"],
+    baseUrl: BASE,
+    defaultModel: "gemini-3.8-flash",
+    listModels: (apiKey) => listModelsHttp({ baseUrl: BASE, apiKey, staticModels: STATIC }),
+    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC }),
+};

package/src/providers/groq.ts

@@ -0,0 +1,20 @@
+import { listModelsHttp, streamChatCompletion } from "./openaiCompatible.js";
+const BASE = "https://api.groq.com/openai/v1";
+const STATIC = [
+    { id: "llama-3.3-70b-versatile", label: "Llama 3.3 70B" },
+    { id: "meta-llama/llama-4-maverick-17b-128e-instruct", label: "Llama 4 Maverick" },
+    { id: "meta-llama/llama-4-scout-17b-16e-instruct", label: "Llama 4 Scout" },
+    { id: "moonshotai/kimi-k2-instruct", label: "Kimi K2" },
+    { id: "openai/gpt-oss-120b", label: "GPT-OSS 120B" },
+    { id: "qwen/qwen3-32b", label: "Qwen3 32B" },
+    { id: "llama-3.1-8b-instant", label: "Llama 3.1 8B instant" },
+];
+export const groqProvider = {
+    id: "groq",
+    label: "Groq",
+    authEnv: ["GROQ_API_KEY"],
+    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 }),
+};

package/src/providers/index.ts

@@ -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/src/providers/mistral.ts

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

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

@@ -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/src/providers/openai.ts

@@ -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/src/providers/openaiCompatible.ts

@@ -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: any = { 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/src/providers/openrouter.ts

@@ -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/src/providers/qwen.ts

@@ -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/src/providers/xai.ts

@@ -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/src/providers/zhipu.ts

@@ -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/src/session/log.ts

@@ -0,0 +1,135 @@
+/**
+ * Append-only JSONL session log.
+ *
+ * Every entry is flushed as its own line, so a crash (or a kill from the
+ * Android task switcher) still leaves a readable transcript that can be
+ * resumed. A size cap keeps the sessions directory bounded; the oldest logs are
+ * pruned first.
+ *
+ *   FASTCODE_SESSION_LOG=0        disable logging
+ *   FASTCODE_SESSION_CACHE_MB=N   sessions cache cap in MB (default 256)
+ */
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { getPaths } from "../config/paths.js";
+const NL = String.fromCharCode(10);
+export function sessionCacheLimitBytes() {
+    const mb = Number(process.env["FASTCODE_SESSION_CACHE_MB"]);
+    return (Number.isFinite(mb) && mb > 0 ? mb : 256) * 1024 * 1024;
+}
+export function loggingEnabled() {
+    return process.env["FASTCODE_SESSION_LOG"] !== "0";
+}
+function newId() {
+    return new Date().toISOString().replace(/[:.]/g, "-") + "-" + Math.random().toString(36).slice(2, 6);
+}
+function openLog(id, file, meta) {
+    let closed = false;
+    const append = (entry) => {
+        if (closed || !loggingEnabled())
+            return;
+        try {
+            appendFileSync(file, JSON.stringify({ ts: Date.now(), ...entry }) + NL, "utf8");
+        }
+        catch {
+            // A read-only or full filesystem must not break the TUI.
+        }
+    };
+    append({ type: "session_start", id, cwd: process.cwd(), ...meta });
+    return {
+        id,
+        file,
+        append,
+        close() {
+            append({ type: "session_end" });
+            closed = true;
+            try {
+                pruneSessions();
+            }
+            catch {
+                // best effort
+            }
+        },
+    };
+}
+export function createSessionLog(meta = {}) {
+    const { sessions } = getPaths();
+    mkdirSync(sessions, { recursive: true });
+    const id = newId();
+    const file = join(sessions, id + ".jsonl");
+    return openLog(id, file, meta);
+}
+export function openSessionLog(file) {
+    const { sessions } = getPaths();
+    mkdirSync(sessions, { recursive: true });
+    return openLog(undefined, existsSync(file) ? file : join(sessions, file), {});
+}
+export function listSessions() {
+    const { sessions } = getPaths();
+    if (!existsSync(sessions))
+        return [];
+    return readdirSync(sessions)
+        .filter((name) => name.endsWith(".jsonl"))
+        .map((name) => {
+            const file = join(sessions, name);
+            let bytes = 0;
+            let modified = "";
+            let messages = 0;
+            try {
+                const info = statSync(file);
+                bytes = info.size;
+                modified = info.mtime.toISOString();
+                messages = readFileSync(file, "utf8").split(NL).filter((line) => line.includes('"type":"message"')).length;
+            }
+            catch {
+                // unreadable: report what we have
+            }
+            return { id: name.replace(/[.]jsonl$/, ""), file, bytes, modified, messages };
+        })
+        .sort((a, b) => (a.modified < b.modified ? 1 : -1));
+}
+export function resolveSessionFile(idOrFile) {
+    const { sessions } = getPaths();
+    const looksLikePath = idOrFile.includes("/") || idOrFile.includes(String.fromCharCode(92)) || idOrFile.endsWith(".jsonl");
+    return looksLikePath ? idOrFile : join(sessions, idOrFile + ".jsonl");
+}
+export function readSession(idOrFile) {
+    const file = resolveSessionFile(idOrFile);
+    if (!existsSync(file))
+        return [];
+    return readFileSync(file, "utf8")
+        .split(NL)
+        .filter(Boolean)
+        .map((line) => {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            return undefined;
+        }
+    })
+        .filter(Boolean);
+}
+export function loadSessionMessages(idOrFile) {
+    return readSession(idOrFile)
+        .filter((entry) => entry.type === "message" && typeof entry.content === "string")
+        .map((entry) => ({ role: entry.role, content: entry.content }));
+}
+export function latestSessionFile() {
+    const all = listSessions();
+    return all.length > 0 ? all[0].file : undefined;
+}
+export function pruneSessions(limit = sessionCacheLimitBytes()) {
+    const all = listSessions();
+    let total = all.reduce((sum, entry) => sum + entry.bytes, 0);
+    for (let i = all.length - 1; i >= 0 && total > limit; i -= 1) {
+        try {
+            rmSync(all[i].file, { force: true });
+            total -= all[i].bytes;
+        }
+        catch {
+            // keep pruning the rest
+        }
+    }
+    return total;
+}