gsd-pi 2.58.0-dev.778d6ac → 2.58.0-dev.d63175c

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

@@ -1,112 +0,0 @@
-// 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

@@ -1,115 +0,0 @@
-// 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

@@ -1,168 +0,0 @@
-// 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

@@ -1,194 +0,0 @@
-// 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

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