@@ -27,7 +27,8 @@ Beyond chat, Modelforge includes an **agentic mode** — the model can read/writ
 ## Features
 
 **Chat & providers**
-- Local Ollama models, OpenAI, Anthropic, **and llama.cpp** in one interface, with token-by-token streaming.
+- Local Ollama models, OpenAI, Anthropic, Google Gemini, **and llama.cpp** in one interface, with token-by-token streaming.
+- **Custom OpenAI-compatible providers** — add Groq, Mistral, DeepSeek, xAI (Grok), OpenRouter, a self-hosted server, or any other endpoint that speaks the OpenAI chat-completions format, via one shared implementation rather than a dedicated client per vendor. Quick-add presets fill in the base URL for the popular ones; you just paste an API key.
 - **llama.cpp backend** — run GGUF models directly via [node-llama-cpp](https://github.com/withcatai/node-llama-cpp) instead of Ollama, with **Vulkan**, CUDA, or Metal GPU acceleration (auto-detected, selectable in Settings). Useful for Vulkan acceleration or models Ollama doesn't package. This is an *additional* backend, not a replacement — Ollama is still fully supported side by side. Agent mode tool-calling isn't wired up for this backend yet (a clear error explains this if you try); everything else (streaming, GPU offload, all the generation parameters) works the same as any other provider. Model weights load once and stay warm across messages, but each turn currently re-evaluates the full conversation from scratch rather than reusing a cache across turns — correct, but slower on long conversations than it could be.
 - Vision support — attach images (or extract frames from a video) for models that can see them. When an image is attached, an **"Analyze as..."** menu fills the composer with a ready-made prompt for common diagram/wireframe tasks — describe the UI, convert it to a Mermaid diagram, generate React + Tailwind code from it, list its components, or review it for usability/accessibility issues.
 - Live token usage and estimated cost per message and per session (Ollama is free/local; cloud providers show a running estimate).
 
@@ -24,15 +24,22 @@ import type { McpServerConfig } from "./mcp-client";
 import type { AttachedFile } from "./file-reader";
 import * as openaiProvider from "./providers/openai";
 import * as anthropicProvider from "./providers/anthropic";
+import * as geminiProvider from "./providers/gemini";
+import { createOpenAiCompatibleChat } from "./providers/openai-compatible";
 import { setupMenu } from "./menu";
 import { setupAutoUpdater, checkForUpdatesManually } from "./updater";
 import type { ChatMessage, ChatChunk, ChatOptions, ProviderId, ToolDefinition } from "./providers/types";
 
-const PROVIDER_SECRET_KEYS: Record<Exclude<ProviderId, "ollama" | "llamacpp">, string> = {
+const PROVIDER_SECRET_KEYS: Record<Exclude<ProviderId, "ollama" | "llamacpp" | "custom">, string> = {
     openai: "openai_api_key",
     anthropic: "anthropic_api_key",
+    gemini: "gemini_api_key",
 };
 
+function customProviderSecretKey(customProviderId: string): string {
+    return `custom_${customProviderId}_api_key`;
+}
+
 const activeChatRequests = new Map<string, AbortController>();
 let isBusy = false;
 let forceClose = false;
@@ -177,11 +184,32 @@ async function dispatchChat(
     } else if (provider === "llamacpp") {
         const modelPath = path.join(getLlamaCppModelsDir(), model);
         await llamacpp.chat(modelPath, messages, options, onToken, signal, tools);
+    } else if (provider === "custom") {
+        // model is "<customProviderId>::<actual model id>" — see
+        // frontend/src/lib/providers.ts's formatCustomModelRef.
+        const sep = model.indexOf("::");
+        if (sep === -1) throw new Error(`Malformed custom model reference: ${model}`);
+        const customProviderId = model.slice(0, sep);
+        const actualModel = model.slice(sep + 2);
+        const config = settingsStore.getSettings().customProviders?.find((p) => p.id === customProviderId);
+        if (!config) throw new Error(`Custom provider "${customProviderId}" is no longer configured.`);
+        const apiKey = secretsStore.getSecret(customProviderSecretKey(customProviderId));
+        if (!apiKey) throw new Error(`No API key set for ${config.name}. Add one in Settings.`);
+        await createOpenAiCompatibleChat(config.baseUrl, config.name)(
+            apiKey,
+            actualModel,
+            messages,
+            options,
+            onToken,
+            signal,
+            tools
+        );
     } else {
         const secretKey = PROVIDER_SECRET_KEYS[provider];
         const apiKey = secretsStore.getSecret(secretKey);
         if (!apiKey) throw new Error(`No API key set for ${provider}. Add one in Settings.`);
-        const providerFn = provider === "openai" ? openaiProvider.chat : anthropicProvider.chat;
+        const providerFn =
+            provider === "openai" ? openaiProvider.chat : provider === "anthropic" ? anthropicProvider.chat : geminiProvider.chat;
         await providerFn(apiKey, model, messages, options, onToken, signal, tools);
     }
 }
 
@@ -0,0 +1,96 @@
+import { describeHttpError, describeNetworkError } from "./errors";
+import { streamSSE } from "./sse";
+import type { ChatFn, ChatMessage } from "./types";
+
+interface GeminiPart {
+    text?: string;
+    inlineData?: { mimeType: string; data: string };
+}
+
+interface GeminiContent {
+    role: "user" | "model";
+    parts: GeminiPart[];
+}
+
+// Gemini's request shape is meaningfully different from the OpenAI-style APIs
+// (system prompt is a separate top-level field, "assistant" is called
+// "model", and there's no "tool" role) — a real implementation, not a thin
+// wrapper over openai-compatible.ts.
+function toGeminiContents(messages: ChatMessage[]): { system?: string; contents: GeminiContent[] } {
+    let system: string | undefined;
+    const contents: GeminiContent[] = [];
+    for (const m of messages) {
+        if (m.role === "system") {
+            system = system ? `${system}\n\n${m.content}` : m.content;
+            continue;
+        }
+        if (m.role === "tool") continue; // not supported yet — see chat() below
+        const parts: GeminiPart[] = [];
+        if (m.content) parts.push({ text: m.content });
+        if (m.images) {
+            for (const img of m.images) parts.push({ inlineData: { mimeType: img.mimeType, data: img.data } });
+        }
+        contents.push({ role: m.role === "assistant" ? "model" : "user", parts });
+    }
+    return { system, contents };
+}
+
+export const chat: ChatFn = async (apiKey, model, messages, options, onToken, signal, tools) => {
+    if (tools && tools.length > 0) {
+        throw new Error(
+            "Agent mode isn't supported yet for Gemini — switch to OpenAI, Claude, or a local model for tool-calling, or turn Agent mode off."
+        );
+    }
+
+    const { system, contents } = toGeminiContents(messages);
+    const url = `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(model)}:streamGenerateContent?alt=sse&key=${encodeURIComponent(apiKey)}`;
+
+    let res: Response;
+    try {
+        res = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                contents,
+                ...(system ? { systemInstruction: { parts: [{ text: system }] } } : {}),
+                generationConfig: {
+                    temperature: options?.temperature ?? 0.7,
+                    topP: options?.topP,
+                    topK: options?.topK,
+                    maxOutputTokens: options?.maxTokens,
+                    stopSequences: options?.stop && options.stop.length > 0 ? options.stop : undefined,
+                },
+            }),
+            signal,
+        });
+    } catch (err) {
+        throw describeNetworkError("Gemini", err);
+    }
+
+    if (!res.ok || !res.body) {
+        throw new Error(await describeHttpError(res, "Gemini"));
+    }
+
+    await streamSSE(res, (payload) => {
+        try {
+            const parsed = JSON.parse(payload);
+            const text = parsed.candidates?.[0]?.content?.parts
+                ?.map((p: GeminiPart) => p.text ?? "")
+                .join("");
+            if (text) onToken({ message: { role: "assistant", content: text }, done: false });
+
+            if (parsed.usageMetadata) {
+                onToken({
+                    done: false,
+                    usage: {
+                        promptTokens: parsed.usageMetadata.promptTokenCount,
+                        completionTokens: parsed.usageMetadata.candidatesTokenCount,
+                    },
+                });
+            }
+        } catch {
+            // ignore malformed payload
+        }
+    });
+    onToken({ done: true });
+};
@@ -0,0 +1,149 @@
+import { streamSSE } from "./sse";
+import { describeHttpError, describeNetworkError } from "./errors";
+import type { ChatFn, ToolDefinition } from "./types";
+
+function toOpenAiTools(tools: ToolDefinition[]): unknown[] {
+    return tools.map((t) => ({
+        type: "function",
+        function: { name: t.name, description: t.description, parameters: t.parameters },
+    }));
+}
+
+// The OpenAI chat-completions request/response shape (and its SSE streaming
+// format) has become a de-facto standard — Groq, Mistral, DeepSeek, xAI, and
+// OpenRouter (among others) all speak it, differing only in base URL and
+// which of the optional fields they actually honor. One implementation
+// parameterized by base URL covers all of them instead of near-duplicate
+// per-vendor clients.
+export function createOpenAiCompatibleChat(baseUrl: string, providerLabel: string): ChatFn {
+    const chat: ChatFn = async (apiKey, model, messages, options, onToken, signal, tools) => {
+        const chatMessages = messages.map((m) => {
+            if (m.role === "tool") {
+                return { role: "tool", tool_call_id: m.toolCallId, content: m.content };
+            }
+
+            const toolCalls =
+                m.toolCalls && m.toolCalls.length > 0
+                    ? m.toolCalls.map((tc) => ({
+                          id: tc.id,
+                          type: "function",
+                          function: { name: tc.name, arguments: JSON.stringify(tc.arguments) },
+                      }))
+                    : undefined;
+
+            if (!m.images || m.images.length === 0) {
+                return { role: m.role, content: m.content, ...(toolCalls ? { tool_calls: toolCalls } : {}) };
+            }
+            return {
+                role: m.role,
+                content: [
+                    ...(m.content ? [{ type: "text", text: m.content }] : []),
+                    ...m.images.map((img) => ({
+                        type: "image_url",
+                        image_url: { url: `data:${img.mimeType};base64,${img.data}` },
+                    })),
+                ],
+            };
+        });
+
+        let res: Response;
+        try {
+            res = await fetch(`${baseUrl.replace(/\/+$/, "")}/chat/completions`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${apiKey}`,
+                },
+                body: JSON.stringify({
+                    model,
+                    messages: chatMessages,
+                    stream: true,
+                    stream_options: { include_usage: true },
+                    temperature: options?.temperature ?? 0.7,
+                    top_p: options?.topP,
+                    max_tokens: options?.maxTokens,
+                    frequency_penalty: options?.frequencyPenalty,
+                    presence_penalty: options?.presencePenalty,
+                    seed: options?.seed,
+                    stop: options?.stop && options.stop.length > 0 ? options.stop : undefined,
+                    ...(tools && tools.length > 0 ? { tools: toOpenAiTools(tools) } : {}),
+                }),
+                signal,
+            });
+        } catch (err) {
+            throw describeNetworkError(providerLabel, err);
+        }
+
+        if (!res.ok || !res.body) {
+            throw new Error(await describeHttpError(res, providerLabel));
+        }
+
+        // Tool-call arguments arrive as fragmented JSON string deltas, indexed
+        // by position in the tool_calls array, across many SSE events — only
+        // valid to parse once the stream signals finish_reason "tool_calls".
+        const pendingToolCalls = new Map<number, { id: string; name: string; argsText: string }>();
+
+        function flushToolCalls(): void {
+            if (pendingToolCalls.size === 0) return;
+            const toolCalls = [...pendingToolCalls.values()].map((tc) => {
+                let args: Record<string, unknown> = {};
+                try {
+                    args = JSON.parse(tc.argsText || "{}");
+                } catch {
+                    // malformed arguments — surface as empty rather than crash the stream
+                }
+                return { id: tc.id, name: tc.name, arguments: args };
+            });
+            pendingToolCalls.clear();
+            onToken({ done: false, toolCalls });
+        }
+
+        await streamSSE(res, (payload) => {
+            if (payload === "[DONE]") {
+                flushToolCalls();
+                onToken({ done: true });
+                return;
+            }
+            try {
+                const parsed = JSON.parse(payload);
+                const choice = parsed.choices?.[0];
+                const delta = choice?.delta;
+
+                if (delta?.content) {
+                    onToken({ message: { role: "assistant", content: delta.content }, done: false });
+                }
+
+                if (delta?.tool_calls) {
+                    for (const tc of delta.tool_calls as Array<{
+                        index: number;
+                        id?: string;
+                        function?: { name?: string; arguments?: string };
+                    }>) {
+                        const existing = pendingToolCalls.get(tc.index) ?? { id: tc.id ?? "", name: "", argsText: "" };
+                        if (tc.id) existing.id = tc.id;
+                        if (tc.function?.name) existing.name = tc.function.name;
+                        if (tc.function?.arguments) existing.argsText += tc.function.arguments;
+                        pendingToolCalls.set(tc.index, existing);
+                    }
+                }
+
+                if (choice?.finish_reason === "tool_calls") {
+                    flushToolCalls();
+                }
+
+                if (parsed.usage) {
+                    onToken({
+                        done: false,
+                        usage: {
+                            promptTokens: parsed.usage.prompt_tokens,
+                            completionTokens: parsed.usage.completion_tokens,
+                        },
+                    });
+                }
+            } catch {
+                // ignore malformed payload
+            }
+        });
+    };
+    return chat;
+}