@datename/fastcode-termux 0.0.0-stage → 0.1.6-beta

package/dist/providers/ollama.d.ts

@@ -0,0 +1,33 @@
+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;
+        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/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,34 @@
+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;
+        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

@@ -0,0 +1,26 @@
+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, reasoning: "openai" }),
+    supportsReasoning: (model) => /^(o\d|gpt-5|gpt-6)/i.test(model),
+};

package/dist/providers/openaiCompatible.d.ts

@@ -0,0 +1,26 @@
+export declare function streamChatCompletion(req: any, opts: any): AsyncGenerator<{
+    delta: string;
+    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>;

package/dist/providers/openaiCompatible.js

@@ -0,0 +1,158 @@
+import { fetchJson, streamSSE } from "../lib/http.js";
+import { finalizeToolCalls, mergeToolCallDelta } from "../lib/native-tools.js";
+/** Build a chat-completions body in the classic or the newer (compat) dialect. */
+function buildBody(req, compat, opts, includeReasoning = true) {
+    const messages = [];
+    if (req.system)
+        messages.push({ role: "system", content: req.system });
+    for (const m of req.messages) {
+        if (m.role === "tool") {
+            messages.push({ role: "tool", tool_call_id: m.toolCallId, content: m.content });
+            continue;
+        }
+        if (m.role === "assistant" && m.toolCalls && m.toolCalls.length > 0) {
+            messages.push({
+                role: "assistant",
+                content: m.content || null,
+                tool_calls: m.toolCalls.map((call) => ({
+                    id: call.id,
+                    type: "function",
+                    function: { name: call.name, arguments: call.arguments },
+                })),
+            });
+            continue;
+        }
+        messages.push({ role: m.role, content: m.content });
+    }
+    const body = { model: req.model, messages, stream: true };
+    if (req.tools && req.tools.length > 0) {
+        body.tools = req.tools;
+        body.tool_choice = "auto";
+    }
+    if (req.maxOutputTokens !== undefined) {
+        if (compat)
+            body.max_completion_tokens = req.maxOutputTokens;
+        else
+            body.max_tokens = req.maxOutputTokens;
+    }
+    if (req.temperature !== undefined && !compat)
+        body.temperature = req.temperature;
+    if (includeReasoning && req.reasoningEffort && req.reasoningEffort !== "auto") {
+        const effort = req.reasoningEffort === "max" ? "high" : req.reasoningEffort;
+        if (opts.reasoning === "openai")
+            body.reasoning_effort = effort;
+        else if (opts.reasoning === "openrouter")
+            body.reasoning = { effort };
+    }
+    return body;
+}
+export async function* streamChatCompletion(req, opts) {
+    const hasReasoning = Boolean(req.reasoningEffort && req.reasoningEffort !== "auto" && opts.reasoning && opts.reasoning !== "none");
+    const send = async (compat, includeReasoning = hasReasoning) => {
+        const headers = {
+            "content-type": "application/json",
+            accept: "text/event-stream",
+            ...(opts.extraHeaders ?? {}),
+        };
+        if (opts.apiKey)
+            headers["authorization"] = (opts.authHeader ?? "Bearer") + " " + opts.apiKey;
+        if (req.clientRequestId)
+            headers["idempotency-key"] = req.clientRequestId;
+        return await fetch(trim(opts.baseUrl) + "/chat/completions", {
+            method: "POST",
+            headers,
+            body: JSON.stringify(buildBody(req, compat, opts, includeReasoning)),
+            signal: req.signal,
+        });
+    };
+    let res = await send(false);
+    if (!res.ok) {
+        let detail = await res.text().catch(() => "");
+        // Some models reject the thinking parameter even though the provider
+        // as a whole accepts it. Drop it once, then keep the request alive.
+        if (res.status === 400 && hasReasoning && /reasoning|thinking|effort|unsupported|unrecognized|unknown parameter/i.test(detail)) {
+            res = await send(false, false);
+            detail = res.ok ? detail : await res.text().catch(() => "");
+        }
+        // Newer OpenAI-style models reject max_tokens and temperature. Retry once
+        // in the compatibility dialect before surfacing the real error.
+        if (!res.ok && res.status === 400 && /max_tokens|max_completion_tokens|temperature|unsupported|unrecognized|unknown parameter/i.test(detail)) {
+            res = await send(true, false);
+            detail = res.ok ? detail : await res.text().catch(() => "");
+        }
+        if (!res.ok) {
+            throw new Error(res.status + " " + res.statusText + ": " + detail.slice(0, 500));
+        }
+    }
+    let usage;
+    const toolCalls = new Map();
+    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 (Array.isArray(choice?.delta?.tool_calls)) {
+            for (const delta of choice.delta.tool_calls)
+                mergeToolCallDelta(toolCalls, delta);
+        }
+        if (Array.isArray(choice?.message?.tool_calls)) {
+            for (const delta of choice.message.tool_calls)
+                mergeToolCallDelta(toolCalls, delta);
+        }
+        if (obj.usage) {
+            usage = {
+                inputTokens: obj.usage.prompt_tokens,
+                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 };
+    }
+    const calls = finalizeToolCalls(toolCalls);
+    yield calls.length > 0 ? { delta: "", done: true, usage, toolCalls: calls } : { 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,34 @@
+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;
+        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/openrouter.js

@@ -0,0 +1,27 @@
+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, reasoning: "openrouter" }),
+    supportsReasoning: () => true,
+};

package/dist/providers/qwen.d.ts

@@ -0,0 +1,34 @@
+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;
+        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/qwen.js

@@ -0,0 +1,24 @@
+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, reasoning: "openai" }),
+    supportsReasoning: () => true,
+};

package/dist/providers/xai.d.ts

@@ -0,0 +1,34 @@
+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;
+        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/xai.js

@@ -0,0 +1,19 @@
+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, reasoning: "openai" }),
+    supportsReasoning: () => true,
+};

package/dist/providers/zhipu.d.ts

@@ -0,0 +1,34 @@
+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;
+        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/zhipu.js

@@ -0,0 +1,24 @@
+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, reasoning: "openai" }),
+    supportsReasoning: () => true,
+};

package/dist/session/log.d.ts

@@ -0,0 +1,52 @@
+export interface ActiveFile {
+    path: string;
+    sha1_8: string;
+    mtime: string;
+}
+export interface SessionSummary {
+    id: string;
+    file: string;
+    cwd: string;
+    providerId: string;
+    model: string;
+    turns: number;
+    activeFiles: ActiveFile[];
+    messages: number;
+    lastTs: number;
+}
+export declare function sessionCacheLimitBytes(): number;
+export declare function loggingEnabled(): boolean;
+export declare function projectionPath(file: string): string;
+export declare function fsyncMode(): "on" | "off" | "auto";
+export declare function fsyncEnabled(type?: string): boolean;
+export declare function createSessionLog(meta?: Record<string, any>): {
+    id: string;
+    file: string;
+    append: (entry: Record<string, any>) => number;
+    count(): number;
+    close(): void;
+};
+export declare function openSessionLog(file: string, meta?: Record<string, any>): {
+    id: string;
+    file: string;
+    append: (entry: Record<string, any>) => number;
+    count(): number;
+    close(): void;
+};
+export declare function listSessions(): {
+    id: string;
+    file: string;
+    bytes: number;
+    modified: string;
+    messages: number;
+}[];
+export declare function resolveSessionFile(idOrFile: string): string;
+export declare function readSession(idOrFile: string): any[];
+export declare function loadSessionMessages(idOrFile: string): {
+    role: any;
+    content: any;
+}[];
+export declare function latestSessionFile(): string | undefined;
+export declare function findUnclosedSessions(): SessionSummary[];
+export declare function latestUnclosedSession(): SessionSummary | undefined;
+export declare function pruneSessions(limit?: number): number;