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

package/src/patch/plan.ts

@@ -0,0 +1,317 @@
+import { closeSync, constants as fsConstants, lstatSync, openSync, readFileSync } from "node:fs";
+import { basename } from "node:path";
+import { sandboxPath } from "../agent/tools/paths.js";
+import { parsePatch, type PatchHunk, type PatchOp } from "./parse.js";
+
+export interface PlannedFile {
+    kind: "add" | "delete" | "update";
+    relPath: string;
+    path: string;
+    moveRel?: string;
+    moveTo?: string;
+    existed: boolean;
+    origMode: number;
+    eol: "\n" | "\r\n";
+    oldContent?: string;
+    newContent?: string;
+    diff: string;
+    changedLines: number;
+}
+
+export interface PatchPlan {
+    files: PlannedFile[];
+    warnings: string[];
+}
+
+export type PlanResult = { ok: true; plan: PatchPlan } | { ok: false; output: string };
+
+export type PatchReview =
+    | { kind: "allow" }
+    | { kind: "deny"; reason: string }
+    | { kind: "pending"; reason: string; changedLines: number };
+
+export function planPatch(patch: string, cwd: string): PlanResult {
+    const parsed = parsePatch(patch);
+    if (parsed.ok === false)
+        return { ok: false, output: parsed.output };
+    const files: PlannedFile[] = [];
+    const warnings: string[] = [];
+    for (const op of parsed.ops) {
+        const planned = planOp(op, cwd, warnings);
+        if (planned.ok === false)
+            return { ok: false, output: planned.output };
+        files.push(planned.file);
+    }
+    return { ok: true, plan: { files, warnings } };
+}
+
+function planOp(op: PatchOp, cwd: string, warnings: string[]): { ok: true; file: PlannedFile } | { ok: false; output: string } {
+    try {
+        const path = sandboxPath(cwd, op.path);
+        if (op.kind === "add") {
+            if (lexists(path))
+                return { ok: false, output: `Add File target already exists: ${op.path}` };
+            const newContent = op.lines.length > 0 ? op.lines.join("\n") + "\n" : "";
+            return {
+                ok: true,
+                file: {
+                    kind: "add",
+                    relPath: op.path,
+                    path,
+                    existed: false,
+                    origMode: 0o644,
+                    eol: "\n",
+                    newContent,
+                    diff: makeDiff(null, op.path, "", newContent, "add"),
+                    changedLines: newContent.split("\n").filter(Boolean).length,
+                },
+            };
+        }
+        if (!lexists(path))
+            return { ok: false, output: `file not found: ${op.path}` };
+        const info = lstatSync(path);
+        if (info.isSymbolicLink())
+            return { ok: false, output: `refusing to patch a symbolic link: ${op.path}` };
+        if (!info.isFile())
+            return { ok: false, output: `not a regular file: ${op.path}` };
+        const oldContent = readNoFollow(path);
+        if (op.kind === "delete") {
+            return {
+                ok: true,
+                file: {
+                    kind: "delete",
+                    relPath: op.path,
+                    path,
+                    existed: true,
+                    origMode: info.mode & 0o777,
+                    eol: detectEol(oldContent),
+                    oldContent,
+                    diff: makeDiff(op.path, null, oldContent, "", "delete"),
+                    changedLines: oldContent.split(/\r?\n/).length,
+                },
+            };
+        }
+        const eol = detectEol(oldContent);
+        if (eol === "\n" && /\r\n/.test(oldContent))
+            warnings.push(`mixed line endings in ${op.path}; writing LF`);
+        let newContent = oldContent;
+        if (op.hunks.length > 0) {
+            const applied = applyHunks(oldContent, op.hunks);
+            if (applied.ok === false)
+                return applied;
+            newContent = applied.content;
+            if (eol === "\r\n")
+                newContent = newContent.replace(/\n/g, "\r\n");
+        }
+        let moveTo: string | undefined;
+        let moveRel: string | undefined;
+        if (op.moveTo) {
+            moveTo = sandboxPath(cwd, op.moveTo);
+            if (lexists(moveTo))
+                return { ok: false, output: `Move target already exists: ${op.moveTo}` };
+            moveRel = op.moveTo;
+        }
+        const diff = makeDiff(op.path, op.moveTo ?? op.path, oldContent, newContent, "update");
+        return {
+            ok: true,
+            file: {
+                kind: "update",
+                relPath: op.path,
+                path,
+                moveRel,
+                moveTo,
+                existed: true,
+                origMode: info.mode & 0o777,
+                eol,
+                oldContent,
+                newContent,
+                diff,
+                changedLines: countChangedLines(oldContent, newContent),
+            },
+        };
+    }
+    catch (err: any) {
+        return { ok: false, output: err?.message ?? String(err) };
+    }
+}
+
+export function reviewPatchPlan(plan: PatchPlan): PatchReview {
+    let changed = 0;
+    for (const file of plan.files) {
+        changed += file.changedLines;
+        if (isHardDenied(file.path))
+            return { kind: "deny", reason: `patch targets a protected path: ${file.relPath}` };
+        if (isSensitivePath(file.path))
+            return { kind: "pending", reason: `patch targets a sensitive path: ${file.relPath}`, changedLines: changed };
+    }
+    if (changed > 200)
+        return { kind: "pending", reason: `patch changes ${changed} lines (limit 200)`, changedLines: changed };
+    return { kind: "allow" };
+}
+
+function isHardDenied(path: string): boolean {
+    const normalized = path.replace(/\\/g, "/").toLowerCase();
+    const segments = normalized.split("/");
+    if (segments.includes(".ssh") || segments.includes(".gnupg"))
+        return true;
+    if (normalized.includes("/.git/hooks/"))
+        return true;
+    if (normalized.includes("/android/data/"))
+        return true;
+    const name = basename(normalized);
+    return name === "auth.json" || name === "trust.json";
+}
+
+function isSensitivePath(path: string): boolean {
+    const normalized = path.replace(/\\/g, "/").toLowerCase();
+    const name = basename(normalized);
+    return name === ".env" || name.startsWith(".env.") || /[.](pem|key|p12|pfx)$/.test(name) || normalized.includes("/.git/hooks/");
+}
+
+function lexists(path: string): boolean {
+    try {
+        lstatSync(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+
+function readNoFollow(path: string): string {
+    const flags = fsConstants.O_RDONLY | (fsConstants.O_NOFOLLOW ?? 0);
+    const fd = openSync(path, flags);
+    try {
+        return readFileSync(fd, "utf8");
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+
+export function detectEol(content: string): "\n" | "\r\n" {
+    const crlf = (content.match(/\r\n/g) ?? []).length;
+    const lf = (content.match(/\n/g) ?? []).length;
+    return crlf > 0 && crlf === lf ? "\r\n" : "\n";
+}
+
+type ApplyHunksResult = { ok: true; content: string } | { ok: false; output: string };
+
+export function applyHunks(oldContent: string, hunks: PatchHunk[]): ApplyHunksResult {
+    const lines = oldContent.split(/\r?\n/);
+    let changed = false;
+    for (const hunk of hunks) {
+        const needle = hunk.lines.filter((line) => line.type !== "+").map((line) => line.text);
+        const replacement = hunk.lines.filter((line) => line.type !== "-").map((line) => line.text);
+        if (needle.length === 0) {
+            const at = lines.length > 0 && lines[lines.length - 1] === "" ? lines.length - 1 : lines.length;
+            lines.splice(at, 0, ...replacement);
+            changed = true;
+            continue;
+        }
+        const verdict = findHunk(lines, needle);
+        if (verdict.ok === false)
+            return verdict;
+        lines.splice(verdict.index, needle.length, ...replacement);
+        changed = true;
+    }
+    if (!changed)
+        return { ok: false, output: "patch made no changes" };
+    return { ok: true, content: lines.join("\n") };
+}
+
+function findHunk(lines: string[], needle: string[]): { ok: true; index: number } | { ok: false; output: string } {
+    for (let level = 0; level < 3; level += 1) {
+        const matches = matchAll(lines, needle, level);
+        if (matches.length === 0)
+            continue;
+        if (matches.length > 1) {
+            return {
+                ok: false,
+                output: `ambiguous patch context (${matches.length} candidates at lines ${matches.map((index) => index + 1).join(", ")}); add surrounding context`,
+            };
+        }
+        return { ok: true, index: matches[0] };
+    }
+    return { ok: false, output: `patch context not found: ${JSON.stringify(needle.slice(0, 4))}` };
+}
+
+function matchAll(lines: string[], needle: string[], level: number): number[] {
+    const found: number[] = [];
+    const wanted = needle.map((line) => normalizeLine(line, level));
+    for (let i = 0; i + needle.length <= lines.length; i += 1) {
+        let match = true;
+        for (let j = 0; j < needle.length; j += 1) {
+            if (normalizeLine(lines[i + j], level) !== wanted[j]) {
+                match = false;
+                break;
+            }
+        }
+        if (match)
+            found.push(i);
+    }
+    return found;
+}
+
+function normalizeLine(line: string, level: number): string {
+    if (level === 0)
+        return line;
+    if (level === 1)
+        return line.replace(/\s+$/, "");
+    return line.replace(/\s+/g, " ").trim();
+}
+
+export function makeDiff(oldPath: string | null, newPath: string | null, oldContent: string, newContent: string, kind: "add" | "delete" | "update"): string {
+    const oldLines = splitDiffLines(oldContent);
+    const newLines = splitDiffLines(newContent);
+    let prefix = 0;
+    while (prefix < oldLines.length && prefix < newLines.length && oldLines[prefix] === newLines[prefix])
+        prefix += 1;
+    let suffix = 0;
+    while (suffix < oldLines.length - prefix && suffix < newLines.length - prefix &&
+        oldLines[oldLines.length - 1 - suffix] === newLines[newLines.length - 1 - suffix])
+        suffix += 1;
+    const oldMiddle = oldLines.slice(prefix, oldLines.length - suffix);
+    const newMiddle = newLines.slice(prefix, newLines.length - suffix);
+    const oldStart = prefix + 1;
+    const newStart = prefix + 1;
+    const header = kind === "add"
+        ? `--- /dev/null\n+++ b/${newPath ?? ""}`
+        : kind === "delete"
+            ? `--- a/${oldPath ?? ""}\n+++ /dev/null`
+            : `--- a/${oldPath ?? ""}\n+++ b/${newPath ?? oldPath ?? ""}`;
+    const body = [
+        `@@ -${oldStart},${oldMiddle.length} +${newStart},${newMiddle.length} @@`,
+        ...oldMiddle.map((line) => "-" + line),
+        ...newMiddle.map((line) => "+" + line),
+    ];
+    return [header, ...body].join("\n");
+}
+
+function splitDiffLines(content: string): string[] {
+    if (content === "")
+        return [];
+    const lines = content.split(/\r?\n/);
+    if (lines.length > 0 && lines[lines.length - 1] === "")
+        lines.pop();
+    return lines;
+}
+
+function countChangedLines(oldContent: string, newContent: string): number {
+    const oldLines = oldContent.split(/\r?\n/);
+    const newLines = newContent.split(/\r?\n/);
+    let changed = 0;
+    let i = 0;
+    let j = 0;
+    while (i < oldLines.length && j < newLines.length) {
+        if (oldLines[i] === newLines[j]) {
+            i += 1;
+            j += 1;
+            continue;
+        }
+        changed += 1;
+        i += 1;
+        j += 1;
+    }
+    return changed + Math.abs(oldLines.length - newLines.length);
+}

package/src/plugins/manager.ts

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

@@ -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: 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: any = {
+            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/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,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/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,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,
+};