gsd-pi 2.57.0-dev.f22a903 → 2.58.0-dev.778d6ac

package/dist/resources/extensions/ollama/index.js

@@ -0,0 +1,112 @@
+// GSD2 — Ollama Extension: First-class local LLM support
+/**
+ * Ollama Extension
+ *
+ * Auto-detects a running Ollama instance, discovers locally pulled models,
+ * and registers them as a first-class provider. No configuration required —
+ * if Ollama is running, models appear automatically.
+ *
+ * Features:
+ * - Auto-discovery of local models via /api/tags
+ * - Capability detection (vision, reasoning, context window)
+ * - /ollama slash commands for model management
+ * - ollama_manage tool for LLM-driven model operations
+ * - Zero-cost model registration (local inference)
+ *
+ * Respects OLLAMA_HOST env var for non-default endpoints.
+ */
+import { importExtensionModule } from "@gsd/pi-coding-agent";
+import * as client from "./ollama-client.js";
+import { discoverModels, getOllamaOpenAIBaseUrl } from "./ollama-discovery.js";
+import { registerOllamaCommands } from "./ollama-commands.js";
+/** Default compat settings for Ollama models via OpenAI-compat endpoint */
+const OLLAMA_COMPAT = {
+    supportsDeveloperRole: false,
+    supportsReasoningEffort: false,
+    supportsUsageInStreaming: false,
+    maxTokensField: "max_tokens",
+    supportsStore: false,
+};
+let toolsPromise = null;
+async function registerOllamaTools(pi) {
+    if (!toolsPromise) {
+        toolsPromise = (async () => {
+            const { registerOllamaTool } = await importExtensionModule(import.meta.url, "./ollama-tool.js");
+            registerOllamaTool(pi);
+        })().catch((error) => {
+            toolsPromise = null;
+            throw error;
+        });
+    }
+    return toolsPromise;
+}
+/** Track whether we've registered models so we can clean up on shutdown */
+let providerRegistered = false;
+/**
+ * Probe Ollama and register discovered models.
+ * Safe to call multiple times — re-discovers and re-registers.
+ */
+async function probeAndRegister(pi) {
+    const running = await client.isRunning();
+    if (!running) {
+        if (providerRegistered) {
+            pi.unregisterProvider("ollama");
+            providerRegistered = false;
+        }
+        return false;
+    }
+    const models = await discoverModels();
+    if (models.length === 0)
+        return true; // Running but no models pulled
+    const baseUrl = getOllamaOpenAIBaseUrl();
+    pi.registerProvider("ollama", {
+        authMode: "none",
+        baseUrl,
+        api: "openai-completions",
+        isReady: () => true,
+        models: models.map((m) => ({
+            id: m.id,
+            name: m.name,
+            reasoning: m.reasoning,
+            input: m.input,
+            cost: m.cost,
+            contextWindow: m.contextWindow,
+            maxTokens: m.maxTokens,
+            compat: OLLAMA_COMPAT,
+        })),
+    });
+    providerRegistered = true;
+    return true;
+}
+export default function ollama(pi) {
+    // Register slash commands immediately (they check Ollama availability themselves)
+    registerOllamaCommands(pi);
+    pi.on("session_start", async (_event, ctx) => {
+        // Register tool (deferred to avoid blocking startup)
+        if (ctx.hasUI) {
+            void registerOllamaTools(pi).catch((error) => {
+                ctx.ui.notify(`Ollama tool failed to load: ${error instanceof Error ? error.message : String(error)}`, "warning");
+            });
+        }
+        else {
+            await registerOllamaTools(pi);
+        }
+        // Async probe — don't block startup
+        probeAndRegister(pi)
+            .then((found) => {
+            if (found && ctx.hasUI) {
+                ctx.ui.setStatus("ollama", "Ollama");
+            }
+        })
+            .catch(() => {
+            // Silently ignore probe failures
+        });
+    });
+    pi.on("session_shutdown", async () => {
+        if (providerRegistered) {
+            pi.unregisterProvider("ollama");
+            providerRegistered = false;
+        }
+        toolsPromise = null;
+    });
+}

package/dist/resources/extensions/ollama/model-capabilities.js

@@ -0,0 +1,115 @@
+// GSD2 — Known model capability table for Ollama models
+/**
+ * Known model family capabilities.
+ * Keys are matched as prefixes against the model name (before the colon/tag).
+ * More specific entries should appear first.
+ */
+const KNOWN_MODELS = [
+    // ─── Reasoning models ───────────────────────────────────────────────
+    ["deepseek-r1", { contextWindow: 131072, reasoning: true }],
+    ["qwq", { contextWindow: 131072, reasoning: true }],
+    // ─── Vision models ──────────────────────────────────────────────────
+    ["llava", { contextWindow: 4096, input: ["text", "image"] }],
+    ["bakllava", { contextWindow: 4096, input: ["text", "image"] }],
+    ["moondream", { contextWindow: 8192, input: ["text", "image"] }],
+    ["llama3.2-vision", { contextWindow: 131072, input: ["text", "image"] }],
+    ["minicpm-v", { contextWindow: 4096, input: ["text", "image"] }],
+    // ─── Code models ────────────────────────────────────────────────────
+    ["codestral", { contextWindow: 262144, maxTokens: 32768 }],
+    ["qwen2.5-coder", { contextWindow: 131072, maxTokens: 32768 }],
+    ["deepseek-coder-v2", { contextWindow: 131072, maxTokens: 16384 }],
+    ["starcoder2", { contextWindow: 16384, maxTokens: 8192 }],
+    ["codegemma", { contextWindow: 8192, maxTokens: 8192 }],
+    ["codellama", { contextWindow: 16384, maxTokens: 8192 }],
+    ["devstral", { contextWindow: 131072, maxTokens: 32768 }],
+    // ─── Llama family ───────────────────────────────────────────────────
+    ["llama3.3", { contextWindow: 131072, maxTokens: 16384 }],
+    ["llama3.2", { contextWindow: 131072, maxTokens: 16384 }],
+    ["llama3.1", { contextWindow: 131072, maxTokens: 16384 }],
+    ["llama3", { contextWindow: 8192, maxTokens: 8192 }],
+    ["llama2", { contextWindow: 4096, maxTokens: 4096 }],
+    // ─── Qwen family ────────────────────────────────────────────────────
+    ["qwen3", { contextWindow: 131072, maxTokens: 32768 }],
+    ["qwen2.5", { contextWindow: 131072, maxTokens: 32768 }],
+    ["qwen2", { contextWindow: 131072, maxTokens: 32768 }],
+    // ─── Gemma family ───────────────────────────────────────────────────
+    ["gemma3", { contextWindow: 131072, maxTokens: 16384 }],
+    ["gemma2", { contextWindow: 8192, maxTokens: 8192 }],
+    // ─── Mistral family ─────────────────────────────────────────────────
+    ["mistral-large", { contextWindow: 131072, maxTokens: 16384 }],
+    ["mistral-small", { contextWindow: 131072, maxTokens: 16384 }],
+    ["mistral-nemo", { contextWindow: 131072, maxTokens: 16384 }],
+    ["mistral", { contextWindow: 32768, maxTokens: 8192 }],
+    ["mixtral", { contextWindow: 32768, maxTokens: 8192 }],
+    // ─── Phi family ─────────────────────────────────────────────────────
+    ["phi4", { contextWindow: 16384, maxTokens: 16384 }],
+    ["phi3.5", { contextWindow: 131072, maxTokens: 16384 }],
+    ["phi3", { contextWindow: 131072, maxTokens: 4096 }],
+    // ─── Command R ──────────────────────────────────────────────────────
+    ["command-r-plus", { contextWindow: 131072, maxTokens: 16384 }],
+    ["command-r", { contextWindow: 131072, maxTokens: 16384 }],
+];
+/**
+ * Look up capabilities for a model by name.
+ * Matches the longest prefix from the known models table.
+ */
+export function getModelCapabilities(modelName) {
+    // Strip tag (everything after the colon) for matching
+    const baseName = modelName.split(":")[0].toLowerCase();
+    for (const [pattern, caps] of KNOWN_MODELS) {
+        if (baseName === pattern || baseName.startsWith(pattern)) {
+            return caps;
+        }
+    }
+    return {};
+}
+/**
+ * Estimate context window from parameter size string (e.g. "7B", "70B", "1.5B").
+ * Used as fallback when model isn't in the known table.
+ */
+export function estimateContextFromParams(parameterSize) {
+    const match = parameterSize.match(/([\d.]+)\s*([BbMm])/);
+    if (!match)
+        return 8192;
+    const size = parseFloat(match[1]);
+    const unit = match[2].toUpperCase();
+    // Convert to billions
+    const billions = unit === "M" ? size / 1000 : size;
+    // Rough heuristics: larger models tend to support larger contexts
+    if (billions >= 70)
+        return 131072;
+    if (billions >= 30)
+        return 65536;
+    if (billions >= 13)
+        return 32768;
+    if (billions >= 7)
+        return 16384;
+    return 8192;
+}
+/**
+ * Humanize a model name for display (e.g. "llama3.1:8b" → "Llama 3.1 8B").
+ */
+export function humanizeModelName(modelName) {
+    const [base, tag] = modelName.split(":");
+    // Capitalize first letter, add spaces around version numbers
+    let name = base
+        .replace(/([a-z])(\d)/g, "$1 $2")
+        .replace(/(\d)([a-z])/g, "$1 $2")
+        .replace(/^./, (c) => c.toUpperCase());
+    // Clean up common patterns
+    name = name.replace(/\s*-\s*/g, " ");
+    if (tag && tag !== "latest") {
+        name += ` ${tag.toUpperCase()}`;
+    }
+    return name;
+}
+/**
+ * Format byte size for display (e.g. 4700000000 → "4.7 GB").
+ */
+export function formatModelSize(bytes) {
+    if (bytes >= 1e9)
+        return `${(bytes / 1e9).toFixed(1)} GB`;
+    if (bytes >= 1e6)
+        return `${(bytes / 1e6).toFixed(1)} MB`;
+    return `${(bytes / 1e3).toFixed(0)} KB`;
+}

package/dist/resources/extensions/ollama/ollama-client.js

@@ -0,0 +1,168 @@
+// GSD2 — HTTP client for Ollama REST API
+const DEFAULT_HOST = "http://localhost:11434";
+const PROBE_TIMEOUT_MS = 1500;
+const REQUEST_TIMEOUT_MS = 10000;
+/**
+ * Get the Ollama host URL from OLLAMA_HOST or default.
+ */
+export function getOllamaHost() {
+    const host = process.env.OLLAMA_HOST;
+    if (!host)
+        return DEFAULT_HOST;
+    // OLLAMA_HOST can be just a host:port without scheme
+    if (host.startsWith("http://") || host.startsWith("https://"))
+        return host;
+    return `http://${host}`;
+}
+async function fetchWithTimeout(url, options = {}, timeoutMs = REQUEST_TIMEOUT_MS) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetch(url, { ...options, signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+/**
+ * Check if Ollama is running and reachable.
+ */
+export async function isRunning() {
+    try {
+        const response = await fetchWithTimeout(`${getOllamaHost()}/`, {}, PROBE_TIMEOUT_MS);
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get Ollama version.
+ */
+export async function getVersion() {
+    try {
+        const response = await fetchWithTimeout(`${getOllamaHost()}/api/version`);
+        if (!response.ok)
+            return null;
+        const data = (await response.json());
+        return data.version;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * List all locally available models.
+ */
+export async function listModels() {
+    const response = await fetchWithTimeout(`${getOllamaHost()}/api/tags`);
+    if (!response.ok) {
+        throw new Error(`Ollama /api/tags returned ${response.status}: ${response.statusText}`);
+    }
+    return (await response.json());
+}
+/**
+ * Get detailed information about a specific model.
+ */
+export async function showModel(name) {
+    const response = await fetchWithTimeout(`${getOllamaHost()}/api/show`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ name }),
+    });
+    if (!response.ok) {
+        throw new Error(`Ollama /api/show returned ${response.status}: ${response.statusText}`);
+    }
+    return (await response.json());
+}
+/**
+ * List currently loaded/running models.
+ */
+export async function getRunningModels() {
+    const response = await fetchWithTimeout(`${getOllamaHost()}/api/ps`);
+    if (!response.ok) {
+        throw new Error(`Ollama /api/ps returned ${response.status}: ${response.statusText}`);
+    }
+    return (await response.json());
+}
+/**
+ * Pull a model with streaming progress.
+ * Calls onProgress for each progress update.
+ * Returns when the pull is complete.
+ */
+export async function pullModel(name, onProgress, signal) {
+    const response = await fetch(`${getOllamaHost()}/api/pull`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ name, stream: true }),
+        signal,
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Ollama /api/pull returned ${response.status}: ${text}`);
+    }
+    if (!response.body) {
+        throw new Error("Ollama /api/pull returned no body");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                const progress = JSON.parse(trimmed);
+                onProgress?.(progress);
+            }
+            catch {
+                // Skip malformed lines
+            }
+        }
+    }
+    // Process remaining buffer
+    if (buffer.trim()) {
+        try {
+            const progress = JSON.parse(buffer.trim());
+            onProgress?.(progress);
+        }
+        catch {
+            // Ignore
+        }
+    }
+}
+/**
+ * Delete a local model.
+ */
+export async function deleteModel(name) {
+    const response = await fetchWithTimeout(`${getOllamaHost()}/api/delete`, {
+        method: "DELETE",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ name }),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Ollama /api/delete returned ${response.status}: ${text}`);
+    }
+}
+/**
+ * Copy a model to a new name.
+ */
+export async function copyModel(source, destination) {
+    const response = await fetchWithTimeout(`${getOllamaHost()}/api/copy`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ source, destination }),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Ollama /api/copy returned ${response.status}: ${text}`);
+    }
+}

package/dist/resources/extensions/ollama/ollama-commands.js

@@ -0,0 +1,194 @@
+// GSD2 — Ollama slash commands
+import { Text } from "@gsd/pi-tui";
+import * as client from "./ollama-client.js";
+import { discoverModels, formatModelForDisplay } from "./ollama-discovery.js";
+import { formatModelSize } from "./model-capabilities.js";
+export function registerOllamaCommands(pi) {
+    pi.registerCommand("ollama", {
+        description: "Manage local Ollama models — list | pull | remove | ps",
+        async handler(args, ctx) {
+            const parts = (args ?? "").trim().split(/\s+/);
+            const subcommand = parts[0] || "status";
+            const modelArg = parts.slice(1).join(" ");
+            switch (subcommand) {
+                case "status":
+                    return await handleStatus(ctx);
+                case "list":
+                case "ls":
+                    return await handleList(ctx);
+                case "pull":
+                    return await handlePull(modelArg, ctx);
+                case "remove":
+                case "rm":
+                case "delete":
+                    return await handleRemove(modelArg, ctx);
+                case "ps":
+                    return await handlePs(ctx);
+                default:
+                    ctx.ui.notify(`Unknown subcommand: ${subcommand}. Use: status, list, pull, remove, ps`, "warning");
+            }
+        },
+    });
+}
+async function handleStatus(ctx) {
+    const running = await client.isRunning();
+    if (!running) {
+        ctx.ui.notify("Ollama is not running. Install from https://ollama.com and run 'ollama serve'", "warning");
+        return;
+    }
+    const version = await client.getVersion();
+    const lines = [];
+    lines.push(`Ollama${version ? ` v${version}` : ""} — running (${client.getOllamaHost()})`);
+    // Show loaded models
+    try {
+        const ps = await client.getRunningModels();
+        if (ps.models && ps.models.length > 0) {
+            lines.push("");
+            lines.push("Loaded:");
+            for (const m of ps.models) {
+                const vram = m.size_vram > 0 ? formatModelSize(m.size_vram) + " VRAM" : "CPU";
+                const expiresAt = new Date(m.expires_at);
+                const idleMs = expiresAt.getTime() - Date.now();
+                const idleMin = Math.max(0, Math.floor(idleMs / 60000));
+                lines.push(`  ${m.name}  ${vram}  expires in ${idleMin}m`);
+            }
+        }
+    }
+    catch {
+        // ps endpoint may not be available on older versions
+    }
+    // Show available models
+    try {
+        const models = await discoverModels();
+        if (models.length > 0) {
+            lines.push("");
+            lines.push("Available:");
+            for (const m of models) {
+                lines.push(`  ${formatModelForDisplay(m)}`);
+            }
+        }
+        else {
+            lines.push("");
+            lines.push("No models pulled. Use /ollama pull <model> to get started.");
+        }
+    }
+    catch (err) {
+        lines.push("");
+        lines.push(`Error listing models: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    await ctx.ui.custom((tui, theme, _kb, done) => {
+        const text = new Text(lines.map((l) => theme.fg("fg", l)).join("\n"), 0, 0);
+        setTimeout(() => done(undefined), 0);
+        return text;
+    });
+}
+async function handleList(ctx) {
+    const running = await client.isRunning();
+    if (!running) {
+        ctx.ui.notify("Ollama is not running", "warning");
+        return;
+    }
+    const models = await discoverModels();
+    if (models.length === 0) {
+        ctx.ui.notify("No models available. Use /ollama pull <model> to download one.", "info");
+        return;
+    }
+    const lines = ["Local Ollama models:", ""];
+    for (const m of models) {
+        lines.push(`  ${formatModelForDisplay(m)}`);
+    }
+    await ctx.ui.custom((tui, theme, _kb, done) => {
+        const text = new Text(lines.map((l) => theme.fg("fg", l)).join("\n"), 0, 0);
+        setTimeout(() => done(undefined), 0);
+        return text;
+    });
+}
+async function handlePull(modelName, ctx) {
+    if (!modelName) {
+        ctx.ui.notify("Usage: /ollama pull <model> (e.g. /ollama pull llama3.1:8b)", "warning");
+        return;
+    }
+    const running = await client.isRunning();
+    if (!running) {
+        ctx.ui.notify("Ollama is not running", "warning");
+        return;
+    }
+    ctx.ui.setWidget("ollama-pull", [`Pulling ${modelName}...`]);
+    try {
+        let lastPercent = -1;
+        await client.pullModel(modelName, (progress) => {
+            if (progress.total && progress.completed) {
+                const percent = Math.floor((progress.completed / progress.total) * 100);
+                if (percent !== lastPercent) {
+                    lastPercent = percent;
+                    const completed = formatModelSize(progress.completed);
+                    const total = formatModelSize(progress.total);
+                    ctx.ui.setWidget("ollama-pull", [
+                        `Pulling ${modelName}... ${percent}% (${completed} / ${total})`,
+                    ]);
+                }
+            }
+            else if (progress.status) {
+                ctx.ui.setWidget("ollama-pull", [`${modelName}: ${progress.status}`]);
+            }
+        });
+        ctx.ui.setWidget("ollama-pull", undefined);
+        ctx.ui.notify(`${modelName} pulled successfully`, "success");
+    }
+    catch (err) {
+        ctx.ui.setWidget("ollama-pull", undefined);
+        ctx.ui.notify(`Failed to pull ${modelName}: ${err instanceof Error ? err.message : String(err)}`, "error");
+    }
+}
+async function handleRemove(modelName, ctx) {
+    if (!modelName) {
+        ctx.ui.notify("Usage: /ollama remove <model>", "warning");
+        return;
+    }
+    const running = await client.isRunning();
+    if (!running) {
+        ctx.ui.notify("Ollama is not running", "warning");
+        return;
+    }
+    const confirmed = await ctx.ui.confirm("Delete model", `Are you sure you want to delete ${modelName}?`);
+    if (!confirmed)
+        return;
+    try {
+        await client.deleteModel(modelName);
+        ctx.ui.notify(`${modelName} deleted`, "success");
+    }
+    catch (err) {
+        ctx.ui.notify(`Failed to delete ${modelName}: ${err instanceof Error ? err.message : String(err)}`, "error");
+    }
+}
+async function handlePs(ctx) {
+    const running = await client.isRunning();
+    if (!running) {
+        ctx.ui.notify("Ollama is not running", "warning");
+        return;
+    }
+    try {
+        const ps = await client.getRunningModels();
+        if (!ps.models || ps.models.length === 0) {
+            ctx.ui.notify("No models currently loaded in memory", "info");
+            return;
+        }
+        const lines = ["Running models:", ""];
+        for (const m of ps.models) {
+            const vram = m.size_vram > 0 ? formatModelSize(m.size_vram) + " VRAM" : "CPU only";
+            const totalSize = formatModelSize(m.size);
+            const expiresAt = new Date(m.expires_at);
+            const idleMs = expiresAt.getTime() - Date.now();
+            const idleMin = Math.max(0, Math.floor(idleMs / 60000));
+            lines.push(`  ${m.name}  ${totalSize}  ${vram}  expires in ${idleMin}m`);
+        }
+        await ctx.ui.custom((tui, theme, _kb, done) => {
+            const text = new Text(lines.map((l) => theme.fg("fg", l)).join("\n"), 0, 0);
+            setTimeout(() => done(undefined), 0);
+            return text;
+        });
+    }
+    catch (err) {
+        ctx.ui.notify(`Failed to get running models: ${err instanceof Error ? err.message : String(err)}`, "error");
+    }
+}

package/dist/resources/extensions/ollama/ollama-discovery.js

@@ -0,0 +1,69 @@
+// GSD2 — Ollama model discovery and capability detection
+/**
+ * Discovers locally available Ollama models and enriches them with
+ * capability metadata (context window, vision, reasoning) from the
+ * known model table and /api/show responses.
+ *
+ * Returns models in the format expected by pi.registerProvider().
+ */
+import { listModels, getOllamaHost } from "./ollama-client.js";
+import { estimateContextFromParams, formatModelSize, getModelCapabilities, humanizeModelName, } from "./model-capabilities.js";
+const ZERO_COST = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+function enrichModel(info) {
+    const caps = getModelCapabilities(info.name);
+    const parameterSize = info.details?.parameter_size ?? "";
+    // Determine context window: known table > estimate from param size > default
+    const contextWindow = caps.contextWindow ??
+        (parameterSize ? estimateContextFromParams(parameterSize) : 8192);
+    // Determine max tokens: known table > fraction of context > default
+    const maxTokens = caps.maxTokens ?? Math.min(Math.floor(contextWindow / 4), 16384);
+    // Detect vision from families or known table
+    const hasVision = caps.input?.includes("image") ??
+        (info.details?.families?.some((f) => f === "clip" || f === "mllama") ?? false);
+    // Detect reasoning from known table
+    const reasoning = caps.reasoning ?? false;
+    return {
+        id: info.name,
+        name: humanizeModelName(info.name),
+        reasoning,
+        input: hasVision ? ["text", "image"] : ["text"],
+        cost: ZERO_COST,
+        contextWindow,
+        maxTokens,
+        sizeBytes: info.size,
+        parameterSize,
+    };
+}
+/**
+ * Discover all locally available Ollama models with enriched capabilities.
+ */
+export async function discoverModels() {
+    const tags = await listModels();
+    if (!tags.models || tags.models.length === 0)
+        return [];
+    return tags.models.map(enrichModel);
+}
+/**
+ * Format a discovered model for display in model list.
+ */
+export function formatModelForDisplay(model) {
+    const parts = [model.id];
+    if (model.sizeBytes > 0) {
+        parts.push(`(${formatModelSize(model.sizeBytes)})`);
+    }
+    const flags = [];
+    if (model.reasoning)
+        flags.push("reasoning");
+    if (model.input.includes("image"))
+        flags.push("vision");
+    if (flags.length > 0) {
+        parts.push(`[${flags.join(", ")}]`);
+    }
+    return parts.join(" ");
+}
+/**
+ * Build the OpenAI-compat base URL for Ollama.
+ */
+export function getOllamaOpenAIBaseUrl() {
+    return `${getOllamaHost()}/v1`;
+}