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

package/dist/plugins/manager.js

@@ -0,0 +1,101 @@
+import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { basename, join, resolve } from "node:path";
+import { getPaths } from "../config/paths.js";
+export function listInstalledPlugins() {
+    const { plugins } = getPaths();
+    if (!existsSync(plugins))
+        return [];
+    return readdirSync(plugins, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => loadPlugin(join(plugins, entry.name), entry.name))
+        .filter((plugin) => plugin !== undefined)
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
+export function getPlugin(name) {
+    return listInstalledPlugins().find((p) => p.name === name || basename(p.path) === name);
+}
+export function importPlugin(source, name) {
+    const { plugins } = getPaths();
+    const src = resolve(source);
+    if (!existsSync(src))
+        throw new Error(`Plugin source does not exist: ${source}`);
+    if (!statSync(src).isDirectory())
+        throw new Error("Plugin source must be a directory");
+    const folder = slugify(name ?? basename(src));
+    const target = join(plugins, folder);
+    if (existsSync(target))
+        rmSync(target, { recursive: true, force: true });
+    mkdirSync(target, { recursive: true });
+    cpSync(src, target, { recursive: true });
+    writeFileSync(join(target, ".fastcode-source"), src);
+    const loaded = loadPlugin(target, folder);
+    if (!loaded)
+        throw new Error("Plugin must include PLUGIN.md, README.md, or at least one SKILL.md");
+    return loaded;
+}
+export function removePlugin(name) {
+    const plugin = getPlugin(name);
+    if (!plugin)
+        return false;
+    rmSync(plugin.path, { recursive: true, force: true });
+    return true;
+}
+export function buildPluginsPrompt(enabled) {
+    if (enabled.length === 0)
+        return "";
+    const plugins = enabled.map(getPlugin).filter((p) => p !== undefined);
+    if (plugins.length === 0)
+        return "";
+    const chunks = plugins.map((plugin) => {
+        const skills = plugin.skills
+            .map((skill) => `<plugin-skill name="${skill.name}">\n${skill.body.trim()}\n</plugin-skill>`)
+            .join("\n\n");
+        return `<plugin name="${plugin.name}">\n${plugin.body.trim()}\n${skills ? `\n\n${skills}` : ""}\n</plugin>`;
+    });
+    return [
+        "",
+        "## Active plugins",
+        "The following plugins are always-active behavior packs. Follow them when relevant:",
+        "",
+        chunks.join("\n\n"),
+    ].join("\n");
+}
+function loadPlugin(path, fallbackName) {
+    const pluginMd = firstExisting([join(path, "PLUGIN.md"), join(path, "README.md")]);
+    const skillsDir = join(path, "skills");
+    const rootSkill = join(path, "SKILL.md");
+    const skills = [];
+    if (existsSync(rootSkill))
+        skills.push({ name: "root", body: readFileSync(rootSkill, "utf8") });
+    if (existsSync(skillsDir)) {
+        for (const entry of readdirSync(skillsDir, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            const skillPath = join(skillsDir, entry.name, "SKILL.md");
+            if (existsSync(skillPath))
+                skills.push({ name: entry.name, body: readFileSync(skillPath, "utf8") });
+        }
+    }
+    if (!pluginMd && skills.length === 0)
+        return undefined;
+    const body = pluginMd ? readFileSync(pluginMd, "utf8") : `Plugin ${fallbackName}`;
+    return {
+        name: fallbackName,
+        description: firstParagraph(body) || `${fallbackName} plugin`,
+        path,
+        body,
+        skills,
+    };
+}
+function firstExisting(paths) {
+    return paths.find((path) => existsSync(path));
+}
+function firstParagraph(markdown) {
+    return markdown
+        .split(/\n\s*\n/)
+        .map((part) => part.replace(/^#+\s*/, "").trim())
+        .find(Boolean);
+}
+function slugify(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "plugin";
+}

package/dist/providers/anthropic.d.ts

@@ -0,0 +1,22 @@
+export declare const anthropicProvider: {
+    id: string;
+    label: string;
+    authEnv: string[];
+    baseUrl: string;
+    defaultModel: string;
+    supportsReasoning(): boolean;
+    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>;
+};

package/dist/providers/anthropic.js

@@ -0,0 +1,119 @@
+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";
+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) {
+            try {
+                const res = await fetch(BASE + "/models", {
+                    headers: { "x-api-key": apiKey, "anthropic-version": "2023-06-01" },
+                });
+                if (res.ok) {
+                    const json = 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 } : {}),
+        };
+        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: {
+                "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/dist/providers/custom.d.ts

@@ -0,0 +1,33 @@
+export declare const customProvider: {
+    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/custom.js

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

@@ -0,0 +1,34 @@
+export declare const deepseekProvider: {
+    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/deepseek.js

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

package/dist/providers/google.d.ts

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

package/dist/providers/google.js

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

@@ -0,0 +1,34 @@
+export declare const groqProvider: {
+    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/groq.js

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

package/dist/providers/index.d.ts

@@ -0,0 +1,10 @@
+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>;

package/dist/providers/index.js

@@ -0,0 +1,67 @@
+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;
+}
+/**
+ * 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

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

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

package/dist/providers/moonshot.d.ts

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

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