@freesyntax/notch-cli 0.5.19 → 0.5.21

package/dist/chunk-443G6HCC.js

@@ -0,0 +1,543 @@
+// src/providers/byok.ts
+import { createOpenAI } from "@ai-sdk/openai";
+import { createAnthropic } from "@ai-sdk/anthropic";
+var BUILTIN_BYOK_PROVIDERS = [
+  {
+    id: "openai",
+    label: "OpenAI",
+    baseUrl: "https://api.openai.com/v1",
+    apiKeyEnv: "OPENAI_API_KEY",
+    defaultModel: "gpt-4o",
+    models: [
+      "gpt-4o",
+      "gpt-4o-mini",
+      "gpt-4-turbo",
+      "gpt-4.1",
+      "gpt-4.1-mini",
+      "gpt-5",
+      "gpt-5-mini",
+      "o3-mini",
+      "o4-mini"
+    ],
+    compatibility: "strict"
+  },
+  {
+    id: "anthropic",
+    label: "Anthropic (Claude)",
+    // Anthropic's OpenAI compat lives at /v1/ (root), not /v1/openai.
+    // See https://platform.claude.com/docs/en/api/openai-sdk
+    baseUrl: "https://api.anthropic.com/v1",
+    apiKeyEnv: "ANTHROPIC_API_KEY",
+    defaultModel: "claude-sonnet-4-6",
+    models: [
+      "claude-opus-4-7",
+      "claude-sonnet-4-6",
+      "claude-haiku-4-5"
+    ],
+    compatibility: "compatible",
+    // anthropic-version is optional on the OpenAI compat layer, but we
+    // pin it so behaviour is deterministic across CLI releases.
+    headers: {
+      "anthropic-version": "2023-06-01"
+    }
+  },
+  {
+    id: "openrouter",
+    label: "OpenRouter",
+    baseUrl: "https://openrouter.ai/api/v1",
+    apiKeyEnv: "OPENROUTER_API_KEY",
+    defaultModel: "anthropic/claude-sonnet-4-6",
+    // OpenRouter exposes hundreds of models — leave undefined and let
+    // users discover via openrouter.ai/models.
+    compatibility: "strict",
+    headers: {
+      "HTTP-Referer": "https://driftrail.com/notch",
+      "X-Title": "Notch CLI"
+    }
+  },
+  {
+    id: "together",
+    label: "Together AI",
+    baseUrl: "https://api.together.xyz/v1",
+    apiKeyEnv: "TOGETHER_API_KEY",
+    defaultModel: "meta-llama/Llama-4-70B-Instruct",
+    models: [
+      "meta-llama/Llama-4-70B-Instruct",
+      "meta-llama/Llama-4-8B-Instruct",
+      "meta-llama/Llama-3.3-70B-Instruct-Turbo",
+      "Qwen/Qwen2.5-72B-Instruct-Turbo",
+      "Qwen/QwQ-32B-Preview",
+      "deepseek-ai/DeepSeek-V3",
+      "mistralai/Mixtral-8x22B-Instruct-v0.1"
+    ],
+    compatibility: "strict"
+  },
+  {
+    id: "fireworks",
+    label: "Fireworks AI",
+    baseUrl: "https://api.fireworks.ai/inference/v1",
+    apiKeyEnv: "FIREWORKS_API_KEY",
+    defaultModel: "accounts/fireworks/models/llama-v4-70b-instruct",
+    models: [
+      "accounts/fireworks/models/llama-v4-70b-instruct",
+      "accounts/fireworks/models/llama-v3p3-70b-instruct",
+      "accounts/fireworks/models/qwen2p5-72b-instruct",
+      "accounts/fireworks/models/deepseek-v3",
+      "accounts/fireworks/models/mixtral-8x22b-instruct"
+    ],
+    compatibility: "strict"
+  },
+  {
+    id: "groq",
+    label: "Groq",
+    baseUrl: "https://api.groq.com/openai/v1",
+    apiKeyEnv: "GROQ_API_KEY",
+    defaultModel: "llama-4-70b-8192",
+    models: [
+      "llama-4-70b-8192",
+      "llama-3.3-70b-versatile",
+      "llama-3.1-8b-instant",
+      "mixtral-8x7b-32768",
+      "gemma2-9b-it",
+      "qwen-qwq-32b"
+    ],
+    compatibility: "strict"
+  },
+  {
+    id: "ollama",
+    label: "Ollama (local)",
+    baseUrl: "http://localhost:11434/v1",
+    apiKeyEnv: "OLLAMA_API_KEY",
+    defaultModel: "llama3.2:latest",
+    // Ollama ignores the api key but openai-compat clients require a
+    // non-empty string. Default to the literal "ollama" per their docs.
+    fallbackApiKey: "ollama",
+    compatibility: "compatible",
+    apiShape: "openai"
+  },
+  {
+    // Same daemon, Anthropic Messages API shape. Ollama v0.14+ serves
+    // /v1/messages at the root (no /v1 suffix on the baseUrl because the
+    // Anthropic SDK owns the path). Higher tool-calling fidelity for
+    // Claude-style agents.
+    id: "ollama-anthropic",
+    label: "Ollama (local, Anthropic-compat)",
+    baseUrl: "http://localhost:11434",
+    apiKeyEnv: "OLLAMA_API_KEY",
+    defaultModel: "qwen3-coder:30b",
+    fallbackApiKey: "ollama",
+    apiShape: "anthropic"
+  },
+  {
+    // Ollama Cloud: same endpoint surface as local, hosted on ollama.com.
+    // Requires OLLAMA_API_KEY from https://ollama.com/settings/keys.
+    id: "ollama-cloud",
+    label: "Ollama Cloud",
+    baseUrl: "https://ollama.com/v1",
+    apiKeyEnv: "OLLAMA_API_KEY",
+    defaultModel: "gpt-oss:120b",
+    models: [
+      "gpt-oss:120b",
+      "gpt-oss:20b",
+      "kimi-k2.5:cloud",
+      "glm-5:cloud",
+      "qwen3.5:cloud",
+      "deepseek-v3.1:671b",
+      "minimax-m2.7:cloud"
+    ],
+    compatibility: "compatible",
+    apiShape: "openai"
+  },
+  {
+    id: "lmstudio",
+    label: "LM Studio (local)",
+    baseUrl: "http://localhost:1234/v1",
+    apiKeyEnv: "",
+    defaultModel: "local-model",
+    fallbackApiKey: "lm-studio",
+    compatibility: "compatible"
+  },
+  {
+    id: "vllm",
+    label: "vLLM (local)",
+    baseUrl: "http://localhost:8000/v1",
+    apiKeyEnv: "",
+    defaultModel: "local-vllm",
+    fallbackApiKey: "EMPTY",
+    compatibility: "strict"
+  },
+  {
+    id: "__custom__",
+    label: "Custom (user-supplied)",
+    // User MUST supply --base-url. These defaults are placeholders that
+    // will fail fast if the user forgets the flag.
+    baseUrl: "",
+    apiKeyEnv: "",
+    defaultModel: "",
+    compatibility: "compatible"
+  }
+];
+var BYOK_BY_ID = Object.fromEntries(
+  BUILTIN_BYOK_PROVIDERS.map((p) => [p.id, p])
+);
+function findByokProvider(id) {
+  return BYOK_BY_ID[id];
+}
+function listByokProviders() {
+  return BUILTIN_BYOK_PROVIDERS.filter((p) => p.id !== "__custom__");
+}
+function isByokRef(model) {
+  return model.includes(":") && !isOllamaTagOnly(model);
+}
+function isOllamaTagOnly(model) {
+  const [head] = model.split(":");
+  if (!head) return false;
+  return !BYOK_BY_ID[head];
+}
+function parseByokRef(ref) {
+  const colon = ref.indexOf(":");
+  if (colon < 0) {
+    throw new Error(`BYOK ref "${ref}" is missing a colon separator.`);
+  }
+  const rawProvider = ref.slice(0, colon);
+  const model = ref.slice(colon + 1);
+  const provider = rawProvider === "custom" ? "__custom__" : rawProvider;
+  return { provider, model };
+}
+var ByokMissingApiKeyError = class extends Error {
+  constructor(provider) {
+    super(
+      provider.apiKeyEnv ? `Missing API key for ${provider.label}. Set ${provider.apiKeyEnv} or pass --api-key.` : `Missing API key for ${provider.label}. Pass --api-key.`
+    );
+    this.provider = provider;
+    this.name = "ByokMissingApiKeyError";
+  }
+  provider;
+};
+var ByokMissingBaseUrlError = class extends Error {
+  constructor() {
+    super(
+      "Custom BYOK provider requires --base-url (and usually --api-key). Example: notch --provider custom --base-url https://my.endpoint/v1 --model my-model"
+    );
+    this.name = "ByokMissingBaseUrlError";
+  }
+};
+function resolveByokModel(spec) {
+  const providerInfo = findByokProvider(spec.provider);
+  if (!providerInfo) {
+    throw new Error(
+      `Unknown BYOK provider "${spec.provider}". Available: ${listByokProviders().map((p) => p.id).join(", ")}, custom`
+    );
+  }
+  if (providerInfo.id === "__custom__" && !spec.baseUrl) {
+    throw new ByokMissingBaseUrlError();
+  }
+  const baseUrl = spec.baseUrl ?? providerInfo.baseUrl;
+  const modelId = spec.model && spec.model.length > 0 ? spec.model : providerInfo.defaultModel;
+  if (!modelId) {
+    throw new Error(
+      `BYOK provider "${providerInfo.id}" has no default model. Pass --model or set byok.model in .notch.json.`
+    );
+  }
+  let apiKey = spec.apiKey;
+  if (!apiKey && providerInfo.apiKeyEnv) {
+    apiKey = process.env[providerInfo.apiKeyEnv];
+  }
+  if (!apiKey && providerInfo.fallbackApiKey) {
+    apiKey = providerInfo.fallbackApiKey;
+  }
+  if (!apiKey && !providerInfo.apiKeyEnv) {
+    apiKey = "not-needed";
+  }
+  if (!apiKey) {
+    throw new ByokMissingApiKeyError(providerInfo);
+  }
+  const headers = {
+    ...providerInfo.headers ?? {},
+    ...spec.headers ?? {}
+  };
+  const shape = spec.apiShape ?? providerInfo.apiShape ?? "openai";
+  if (shape === "anthropic") {
+    const anthropic = createAnthropic({
+      apiKey,
+      baseURL: baseUrl,
+      headers
+    });
+    return {
+      model: anthropic(modelId),
+      providerInfo,
+      modelId
+    };
+  }
+  const provider = createOpenAI({
+    apiKey,
+    baseURL: baseUrl,
+    headers,
+    // Anthropic's compat layer and some shims reject unknown fields —
+    // `compatibility: 'compatible'` tells @ai-sdk/openai to stick to the
+    // lowest-common-denominator feature set.
+    compatibility: providerInfo.compatibility ?? "compatible"
+  });
+  return {
+    model: provider(modelId),
+    providerInfo,
+    modelId
+  };
+}
+async function validateByokConfig(spec) {
+  const providerInfo = findByokProvider(spec.provider);
+  if (!providerInfo) {
+    return { ok: false, error: `Unknown BYOK provider "${spec.provider}"` };
+  }
+  if (providerInfo.id === "__custom__" && !spec.baseUrl) {
+    return { ok: false, error: "Custom provider requires --base-url" };
+  }
+  const baseUrl = spec.baseUrl ?? providerInfo.baseUrl;
+  if (!baseUrl) {
+    return { ok: false, error: `No base URL for ${providerInfo.label}` };
+  }
+  const apiKey = spec.apiKey ?? (providerInfo.apiKeyEnv ? process.env[providerInfo.apiKeyEnv] : void 0) ?? providerInfo.fallbackApiKey;
+  if (providerInfo.apiKeyEnv && !apiKey) {
+    return {
+      ok: false,
+      error: `${providerInfo.label}: set ${providerInfo.apiKeyEnv} or pass --api-key`
+    };
+  }
+  return { ok: true };
+}
+
+// src/providers/registry.ts
+import { createOpenAI as createOpenAI2 } from "@ai-sdk/openai";
+var MissingApiKeyError = class extends Error {
+  /** Which flow caused this error (informs the onboarding message). */
+  flow;
+  /** Env var name the user can set to fix it. */
+  envVar;
+  /** Human-friendly provider label (e.g. "OpenRouter"). */
+  providerLabel;
+  constructor(opts) {
+    const flow = opts?.flow ?? "notch";
+    const envVar = opts?.envVar ?? "NOTCH_API_KEY";
+    const providerLabel = opts?.providerLabel ?? "Notch";
+    super(`${envVar} is not set (${providerLabel})`);
+    this.name = "MissingApiKeyError";
+    this.flow = flow;
+    this.envVar = envVar;
+    this.providerLabel = providerLabel;
+  }
+};
+var MODEL_CATALOG = {
+  "notch-pyre": {
+    id: "notch-pyre",
+    label: "Pyre",
+    size: "9B",
+    gpu: "L40S",
+    contextWindow: 131072,
+    maxOutputTokens: 16384,
+    baseUrl: "https://acemagnifique--notch-serve-pyre-notchpyreserver-serve.modal.run/v1"
+  },
+  "notch-ignis": {
+    id: "notch-ignis",
+    label: "Ignis",
+    size: "27B",
+    gpu: "A100-80GB",
+    contextWindow: 131072,
+    maxOutputTokens: 16384,
+    baseUrl: "https://acemagnifique--notch-serve-ignis-notchignisserver-serve.modal.run/v1"
+  },
+  "notch-solace": {
+    id: "notch-solace",
+    label: "Solace",
+    size: "31B",
+    gpu: "A100-80GB",
+    contextWindow: 131072,
+    maxOutputTokens: 16384,
+    baseUrl: "https://acemagnifique--notch-serve-solace-notchsolaceserver-serve.modal.run/v1"
+  },
+  "notch-solace-lite": {
+    id: "notch-solace-lite",
+    label: "Solace Lite",
+    size: "E4B",
+    gpu: "L4",
+    contextWindow: 65536,
+    maxOutputTokens: 8192,
+    baseUrl: "https://acemagnifique--notch-serve-solace-lite-notchsolacelitese-0e4da6.modal.run/v1"
+  }
+};
+var MODEL_IDS = Object.keys(MODEL_CATALOG);
+function isValidModel(id) {
+  return id in MODEL_CATALOG;
+}
+function modelSupportsImages(modelId) {
+  if (!modelId) return false;
+  if (modelId in MODEL_CATALOG) return true;
+  if (modelId.startsWith("notch-")) return true;
+  const prefix = modelId.split(":", 1)[0]?.toLowerCase() ?? "";
+  switch (prefix) {
+    case "openai":
+    case "anthropic":
+    case "google":
+    case "together":
+    case "openrouter":
+      return true;
+    case "groq":
+      return false;
+    default:
+      return false;
+  }
+}
+function resolveModel(config) {
+  if (config.byokProvider) {
+    const resolved = resolveByokModel({
+      provider: config.byokProvider,
+      model: typeof config.model === "string" && config.model.length > 0 ? config.model : void 0,
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl,
+      headers: { ...config.headers, ...config.byokHeaders },
+      apiShape: config.byokApiShape
+    });
+    return resolved.model;
+  }
+  if (typeof config.model === "string" && isByokRef(config.model)) {
+    const { provider: provider2, model } = parseByokRef(config.model);
+    const resolved = resolveByokModel({
+      provider: provider2,
+      model,
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl,
+      headers: { ...config.headers, ...config.byokHeaders },
+      apiShape: config.byokApiShape
+    });
+    return resolved.model;
+  }
+  const info = MODEL_CATALOG[config.model];
+  if (!info) {
+    throw new Error(
+      `Unknown model "${config.model}". Notch models: ${MODEL_IDS.join(", ")}. For BYOK use "<provider>:<model>" (e.g. openrouter:anthropic/claude-sonnet-4-6).`
+    );
+  }
+  const baseUrl = config.baseUrl ?? process.env.NOTCH_BASE_URL ?? info.baseUrl;
+  const apiKey = config.apiKey ?? process.env.NOTCH_API_KEY;
+  if (!apiKey) {
+    throw new MissingApiKeyError({ flow: "notch", envVar: "NOTCH_API_KEY", providerLabel: "Notch" });
+  }
+  const proxyKey = process.env.MODAL_PROXY_KEY;
+  const proxySecret = process.env.MODAL_PROXY_SECRET;
+  const modalProxyHeaders = proxyKey && proxySecret ? { "Modal-Key": proxyKey, "Modal-Secret": proxySecret } : {};
+  const provider = createOpenAI2({
+    apiKey,
+    baseURL: baseUrl,
+    headers: { ...modalProxyHeaders, ...config.headers }
+  });
+  return provider(config.model);
+}
+async function validateConfig(config) {
+  if (config.byokProvider) {
+    return validateByokConfig({
+      provider: config.byokProvider,
+      model: typeof config.model === "string" && config.model.length > 0 ? config.model : void 0,
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl,
+      headers: { ...config.headers, ...config.byokHeaders },
+      apiShape: config.byokApiShape
+    });
+  }
+  if (typeof config.model === "string" && isByokRef(config.model)) {
+    const { provider, model } = parseByokRef(config.model);
+    return validateByokConfig({
+      provider,
+      model,
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl,
+      headers: { ...config.headers, ...config.byokHeaders },
+      apiShape: config.byokApiShape
+    });
+  }
+  const info = MODEL_CATALOG[config.model];
+  if (!info) {
+    return { ok: false, error: `Unknown model "${config.model}". Available: ${MODEL_IDS.join(", ")}` };
+  }
+  const baseUrl = config.baseUrl ?? process.env.NOTCH_BASE_URL ?? info.baseUrl;
+  const proxyKey = process.env.MODAL_PROXY_KEY;
+  const proxySecret = process.env.MODAL_PROXY_SECRET;
+  const proxyHeaders = proxyKey && proxySecret ? { "Modal-Key": proxyKey, "Modal-Secret": proxySecret } : {};
+  try {
+    const res = await fetch(`${baseUrl.replace(/\/v1$/, "")}/health`, {
+      signal: AbortSignal.timeout(5e3),
+      headers: proxyHeaders
+    });
+    if (!res.ok) {
+      return { ok: false, error: `Notch ${info.label} returned ${res.status} at ${baseUrl}` };
+    }
+    return { ok: true };
+  } catch {
+    return { ok: false, error: `Cannot reach Notch ${info.label} at ${baseUrl}` };
+  }
+}
+
+// src/providers/ollama-credentials.ts
+import fs from "fs/promises";
+import path from "path";
+function notchConfigDir() {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  if (xdg) return path.join(xdg, "notch");
+  const appdata = process.env.APPDATA;
+  if (appdata && process.platform === "win32") return path.join(appdata, "notch");
+  const home = process.env.HOME ?? process.env.USERPROFILE;
+  if (!home) {
+    throw new Error("Cannot determine home directory for credential storage.");
+  }
+  return path.join(home, ".config", "notch");
+}
+function ollamaCredsPath() {
+  return path.join(notchConfigDir(), "ollama.json");
+}
+async function readOllamaCreds() {
+  try {
+    const raw = await fs.readFile(ollamaCredsPath(), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.apiKey !== "string" || typeof parsed.endpoint !== "string") return null;
+    return {
+      apiKey: parsed.apiKey,
+      endpoint: parsed.endpoint,
+      createdAt: typeof parsed.createdAt === "number" ? parsed.createdAt : Date.now()
+    };
+  } catch {
+    return null;
+  }
+}
+async function writeOllamaCreds(creds) {
+  const dir = notchConfigDir();
+  await fs.mkdir(dir, { recursive: true, mode: 448 });
+  const file = ollamaCredsPath();
+  await fs.writeFile(file, JSON.stringify(creds, null, 2) + "\n", { mode: 384 });
+}
+async function clearOllamaCreds() {
+  try {
+    await fs.unlink(ollamaCredsPath());
+  } catch (err) {
+    const code = err.code;
+    if (code !== "ENOENT") throw err;
+  }
+}
+
+export {
+  findByokProvider,
+  listByokProviders,
+  isByokRef,
+  parseByokRef,
+  ByokMissingApiKeyError,
+  ByokMissingBaseUrlError,
+  resolveByokModel,
+  MissingApiKeyError,
+  MODEL_CATALOG,
+  MODEL_IDS,
+  isValidModel,
+  modelSupportsImages,
+  resolveModel,
+  validateConfig,
+  ollamaCredsPath,
+  readOllamaCreds,
+  writeOllamaCreds,
+  clearOllamaCreds
+};

package/dist/chunk-GFVLHUSS.js

@@ -0,0 +1,155 @@
+// src/providers/ollama.ts
+var OLLAMA_LOCAL_BASE_URL = "http://localhost:11434";
+var OLLAMA_CLOUD_BASE_URL = "https://ollama.com";
+var DEFAULT_TIMEOUT_MS = 5e3;
+function authHeaders(apiKey) {
+  return apiKey ? { Authorization: `Bearer ${apiKey}` } : {};
+}
+function joinUrl(baseUrl, path) {
+  const root = baseUrl.replace(/\/+$/, "");
+  const suffix = path.startsWith("/") ? path : `/${path}`;
+  return `${root}${suffix}`;
+}
+async function detectDaemon(baseUrl = OLLAMA_LOCAL_BASE_URL, opts = {}) {
+  try {
+    const res = await fetch(joinUrl(baseUrl, "/api/tags"), {
+      signal: AbortSignal.timeout(opts.timeoutMs ?? DEFAULT_TIMEOUT_MS),
+      headers: authHeaders(opts.apiKey)
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+async function listModels(baseUrl = OLLAMA_LOCAL_BASE_URL, opts = {}) {
+  const res = await fetch(joinUrl(baseUrl, "/api/tags"), {
+    signal: AbortSignal.timeout(opts.timeoutMs ?? DEFAULT_TIMEOUT_MS),
+    headers: authHeaders(opts.apiKey)
+  });
+  if (!res.ok) {
+    throw new Error(`Ollama ${baseUrl} returned ${res.status} for /api/tags`);
+  }
+  const body = await res.json();
+  const models = body.models ?? [];
+  return models.map((m) => ({
+    name: m.name,
+    parameterSize: m.details?.parameter_size ?? "\u2014",
+    quantization: m.details?.quantization_level ?? "\u2014",
+    sizeBytes: m.size ?? 0,
+    modifiedAt: m.modified_at
+  }));
+}
+async function showModel(modelName, baseUrl = OLLAMA_LOCAL_BASE_URL, opts = {}) {
+  const res = await fetch(joinUrl(baseUrl, "/api/show"), {
+    method: "POST",
+    signal: AbortSignal.timeout(opts.timeoutMs ?? DEFAULT_TIMEOUT_MS),
+    headers: { "Content-Type": "application/json", ...authHeaders(opts.apiKey) },
+    body: JSON.stringify({ name: modelName })
+  });
+  if (!res.ok) {
+    throw new Error(`Ollama /api/show(${modelName}) returned ${res.status}`);
+  }
+  const body = await res.json();
+  const info = body.model_info ?? {};
+  let contextLength;
+  for (const [key, value] of Object.entries(info)) {
+    if (key.endsWith(".context_length") && typeof value === "number") {
+      contextLength = value;
+      break;
+    }
+  }
+  return {
+    contextLength,
+    parameterSize: body.details?.parameter_size,
+    family: body.details?.family,
+    modelInfo: info
+  };
+}
+async function* pullModel(modelName, baseUrl = OLLAMA_LOCAL_BASE_URL, opts = {}) {
+  const res = await fetch(joinUrl(baseUrl, "/api/pull"), {
+    method: "POST",
+    signal: opts.signal,
+    headers: { "Content-Type": "application/json", ...authHeaders(opts.apiKey) },
+    body: JSON.stringify({ name: modelName, stream: true })
+  });
+  if (!res.ok || !res.body) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`Ollama /api/pull returned ${res.status}${text ? `: ${text.slice(0, 200)}` : ""}`);
+  }
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buf = "";
+  let done = false;
+  while (!done) {
+    const { value, done: streamDone } = await reader.read();
+    if (streamDone) break;
+    buf += decoder.decode(value, { stream: true });
+    let nl = buf.indexOf("\n");
+    while (nl >= 0) {
+      const line = buf.slice(0, nl).trim();
+      buf = buf.slice(nl + 1);
+      nl = buf.indexOf("\n");
+      if (!line) continue;
+      let frame;
+      try {
+        frame = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (frame.error) {
+        throw new Error(`Ollama pull error: ${frame.error}`);
+      }
+      const status = frame.status ?? "";
+      if (status === "success") {
+        done = true;
+        break;
+      }
+      if (typeof frame.total === "number" && typeof frame.completed === "number" && frame.total > 0) {
+        yield {
+          kind: "progress",
+          message: status,
+          completed: frame.completed,
+          total: frame.total,
+          percent: Math.min(100, frame.completed / frame.total * 100)
+        };
+      } else if (status) {
+        yield { kind: "status", message: status };
+      }
+    }
+  }
+  yield { kind: "done" };
+}
+function isCloudBaseUrl(baseUrl) {
+  try {
+    const host = new URL(baseUrl).hostname;
+    return host === "ollama.com" || host.endsWith(".ollama.com");
+  } catch {
+    return false;
+  }
+}
+function isCloudModel(modelName) {
+  return /(^|[:\-])cloud$/i.test(modelName) || modelName.endsWith(":cloud");
+}
+function formatBytes(n) {
+  if (!n || n <= 0) return "       \u2014";
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let v = n;
+  let i = 0;
+  while (v >= 1024 && i < units.length - 1) {
+    v /= 1024;
+    i++;
+  }
+  return `${v.toFixed(v >= 10 ? 0 : 1)} ${units[i]}`.padStart(8);
+}
+
+export {
+  OLLAMA_LOCAL_BASE_URL,
+  OLLAMA_CLOUD_BASE_URL,
+  detectDaemon,
+  listModels,
+  showModel,
+  pullModel,
+  isCloudBaseUrl,
+  isCloudModel,
+  formatBytes
+};