@7n/tauri-components 0.10.1 → 0.11.1

package/src/core/omlx-models.js

@@ -1,34 +0,0 @@
-// List the models a local omlx (OpenAI-compatible) server has loaded, via
-// GET {baseUrl}/models. Generic OpenAI shape: { data: [{ id }] }. Returns [] on
-// any failure so a model picker degrades gracefully to manual entry.
-
-/**
- * @param {{ baseUrl?: string, apiKey?: string, fetchFn?: typeof fetch, signal?: AbortSignal }} [params] config
- * @returns {Promise<string[]>} loaded model ids (empty on error)
- */
-export async function listOmlxModels({ baseUrl, apiKey, fetchFn = fetch, signal } = {}) {
-  if (!baseUrl) return []
-  try {
-    const response = await fetchFn(`${baseUrl}/models`, {
-      headers: apiKey ? { authorization: `Bearer ${apiKey}` } : {},
-      signal,
-    })
-    if (!response.ok) return []
-    const data = await response.json()
-    return Array.isArray(data?.data) ? data.data.map(m => m?.id).filter(Boolean) : []
-  }
-  catch {
-    return []
-  }
-}
-
-/**
- * Pick a model: the preferred one if loaded, else the first available, else ''.
- * @param {string[]} models loaded model ids
- * @param {string} [preferred] preferred id
- * @returns {string} chosen model id
- */
-export function resolveModel(models, preferred) {
-  if (preferred && models.includes(preferred)) return preferred
-  return models[0] ?? ''
-}

package/src/core/resolve-omlx-base-url.js

@@ -1,84 +0,0 @@
-// Resolve the effective omlx base URL: when the myllm reverse proxy
-// (a Tauri app that forwards /v1/* to the real omlx server and logs every
-// request/response for its history view) is alive on its well-known local
-// port, route traffic through it; otherwise talk to omlx directly. The probe
-// hits {proxy origin}/health — the proxy forwards it to omlx itself, so a
-// 2xx proves BOTH the proxy and the upstream are up (omlx down behind a live
-// proxy yields 502 → direct). Framework-free so headless consumers (MCP
-// wrappers, node scripts) can reuse it; pass a Tauri fetch as fetchFn from
-// webview contexts to avoid CORS on localhost.
-
-export const DIRECT_OMLX_BASE_URL = 'http://127.0.0.1:8000/v1'
-export const PROXY_OMLX_BASE_URL = 'http://127.0.0.1:8088/v1'
-
-const DEFAULT_TIMEOUT_MS = 400
-const DEFAULT_TTL_MS = 12_000
-
-/**
- * Is this URL the default local omlx server — the only target eligible for
- * the proxy override? A user who deliberately pointed an app at another
- * host/port must never be silently rerouted (the proxy's upstream is
- * hardwired to the local :8000).
- * @param {string} url candidate base URL
- * @returns {boolean} true for 127.0.0.1:8000 / localhost:8000, false otherwise (incl. parse errors)
- */
-export function isDirectOmlxUrl(url) {
-  try {
-    const { host } = new URL(url)
-    return host === '127.0.0.1:8000' || host === 'localhost:8000'
-  }
-  catch {
-    return false
-  }
-}
-
-/**
- * One-shot probe: GET {proxy origin}/health with a short timeout. 2xx means
- * the proxy (and omlx behind it) is alive → use the proxy; anything else
- * (timeout, refused, 502) → use the direct URL.
- * @param {{ directUrl?: string, proxyUrl?: string, fetchFn?: typeof fetch, timeoutMs?: number }} [params] config
- * @returns {Promise<string>} the base URL to use
- */
-export async function resolveOmlxBaseUrl({
-  directUrl = DIRECT_OMLX_BASE_URL,
-  proxyUrl = PROXY_OMLX_BASE_URL,
-  fetchFn = fetch,
-  timeoutMs = DEFAULT_TIMEOUT_MS,
-} = {}) {
-  try {
-    const healthUrl = new URL('/health', proxyUrl).toString()
-    const signal = typeof AbortSignal?.timeout === 'function' ? AbortSignal.timeout(timeoutMs) : undefined
-    const response = await fetchFn(healthUrl, { signal })
-    return response.ok ? proxyUrl : directUrl
-  }
-  catch {
-    return directUrl
-  }
-}
-
-// proxyUrl → { promise, expiresAt }. Caching the promise (not the value)
-// dedupes concurrent probes: several composables firing loadEnv() at once
-// trigger a single /health request.
-const cache = new Map()
-
-/**
- * Cached {@link resolveOmlxBaseUrl}: at most one probe per proxyUrl per TTL
- * window, so callers may resolve before every LLM call without paying the
- * probe latency each time, while still noticing the proxy starting/stopping
- * within one TTL.
- * @param {{ directUrl?: string, proxyUrl?: string, fetchFn?: typeof fetch, timeoutMs?: number, ttlMs?: number, now?: () => number }} [params] config
- * @returns {Promise<string>} the base URL to use
- */
-export function resolveOmlxBaseUrlCached({ ttlMs = DEFAULT_TTL_MS, now = Date.now, ...probeOptions } = {}) {
-  const proxyUrl = probeOptions.proxyUrl ?? PROXY_OMLX_BASE_URL
-  const cached = cache.get(proxyUrl)
-  if (cached && now() < cached.expiresAt) return cached.promise
-  const promise = resolveOmlxBaseUrl(probeOptions)
-  cache.set(proxyUrl, { promise, expiresAt: now() + ttlMs })
-  return promise
-}
-
-/** Test hook: drop all cached probe results. */
-export function __resetOmlxBaseUrlCache() {
-  cache.clear()
-}

package/src/vue/docs/use-agent.md

@@ -1,29 +0,0 @@
----
-docgen:
-  source: npm/src/vue/use-agent.js
-  crc: 84427f61
-  model: omlx/gemma-4-e4b-it-OptiQ-4bit
-  score: 100
-  judgeModel: openai-codex/gpt-5.4-mini
----
-
-# use-agent.js
-
-## Огляд
-
-Модуль ініціалізує шлюз агента, надаючи йому інструменти, системний промпт та конфігурацію. Він дозволяє ініціювати запити до агента через `useAgent`, отримувати відповіді, затверджувати дії та переглядати доступні моделі. Звернення до мережі здійснюється через цей модуль.
-
-## Поведінка
-
-1. Викликати `useAgent` для ініціалізації шлюзу агента.
-2. Надати `useAgent` каталог інструментів, системний промпт, опціональне заземлення, рівні акторів, ідентичність актора, конфігурацію omlx та транспорт для інструментів.
-3. Отримати з `useAgent` посилання на базовий URL, модель, ключ API та функції для роботи з omlx.
-4. Отримати з `useAgent` посилання на журнал.
-5. Викликати `request` з отриманого шлюзу, передаючи намір та ідентичність актора, щоб ініціювати запит агента.
-6. Викликати `respond` з отриманого шлюзу, передаючи ідентифікатор запиту та повідомлення, щоб надати відповідь агенту.
-7. Викликати `approve` з отриманого шлюзу, передаючи ідентифікатор запиту та результат схвалення, щоб затвердити дію агента.
-8. Викликати `listModels` з отриманого шлюзу, щоб отримати список доступних моделей omlx.
-
-## Гарантії поведінки
-
-- (специфічних машинно-виведених гарантій немає)

package/src/vue/docs/use-omlx.md

@@ -1,30 +0,0 @@
----
-docgen:
-  source: npm/src/vue/use-omlx.js
-  crc: d1e34b0a
-  model: omlx/gemma-4-e4b-it-OptiQ-4bit
-  score: 100
-  issues: judge:inaccurate:0.98
-  judgeModel: openai-codex/gpt-5.4-mini
----
-
-# use-omlx.js
-
-## Огляд
-
-Модуль відповідає за ініціалізацію та кешування конфігурації для взаємодії з OMLX. Він завантажує налаштування з `settings.json` та середовища виконання, використовуючи <http://127.0.0.1:8000/v1> як резервний URL. Публічна функція useOmlx звертається до мережі, виконує кешування у межах прогону. При виникненні помилок вона перехоплює їх (fail-safe), не кидаючи винятків назовні, а повертаючи порожнє значення замість винятку.
-
-## Поведінка
-
-1. Ініціалізує конфігурацію OMLX, використовуючи значення з локального сховища. Якщо значення відсутнє, використовує наданий за замовчуванням URL, який може бути `http://127.0.0.1:8000/v1`.
-2. Завантажує глобальні налаштування OMLX з середовища виконання через Rust.
-3. Якщо завантаження успішне, застосовує API ключ до внутрішнього стану.
-4. Якщо локальне сховище відсутнє, застосовує URL та модель з глобальних налаштувань.
-5. Якщо URL відповідає локальному замовленню, виконується перенаправлення через проксі myllm, що є тимчасовим перевизначенням.
-6. Зберігає поточні значення URL та моделі у локальне сховище.
-
-## Гарантії поведінки
-
-- Перехоплює помилки і не пропускає винятків назовні (fail-safe).
-- За певних помилок повертає порожнє значення (напр. `null`) замість винятку.
-- Кешує результати в межах одного прогону.

package/src/vue/use-agent.js

@@ -1,60 +0,0 @@
-import { fetch as tauriFetch } from '@tauri-apps/plugin-http'
-import { createAgentKit } from '../core/agent-kit.js'
-import { createOpenAiChat } from '../core/llm.js'
-import { listOmlxModels } from '../core/omlx-models.js'
-import { createTauriJournalStore } from './journal-store-tauri.js'
-import { tauriTransport } from './transports.js'
-import { useOmlx } from './use-omlx.js'
-
-// In-app agent gateway: binds an app's catalog/prompt to the webview transports —
-// omlx via tauri-http, tools via Tauri invoke, journal via the tauri-plugin-agent
-// commands. Returns a flat surface the dialogs consume: request(intent),
-// respond(id, msg), approve(id, ok) plus the omlx config refs and the journal.
-//
-// Apps pass their catalog + systemPrompt (+ optional grounding/omlx defaults);
-// everything Tauri-specific is wired here so feature dialogs stay domain-free.
-
-const DEFAULT_ACTOR = { kind: 'human', id: 'local' }
-
-/**
- * @param {object} config gateway config
- * @param {object[]} config.catalog app tool catalog (required)
- * @param {string|((ctx: object) => string)} [config.systemPrompt] domain prompt or builder
- * @param {{ tool: string, key?: string, fallback?: unknown }} [config.grounding] optional prompt grounding
- * @param {Record<string, number>} [config.actorTiers] tier overrides
- * @param {{ kind: string, id: string }} [config.actor] caller identity (default human:local)
- * @param {{ storagePrefix?: string, defaultBaseUrl?: string, defaultModel?: string }} [config.omlx] omlx config options
- * @param {(tool: object, input: object) => unknown} [config.transport] tool transport (default Tauri invoke); override to route some tools elsewhere (e.g. JS/OPFS-backed handlers)
- * @returns {object} in-app agent gateway
- */
-export function useAgent({ catalog, systemPrompt, grounding, actorTiers, actor = DEFAULT_ACTOR, omlx, transport = tauriTransport } = {}) {
-  const { baseUrl, model, apiKey, save, loadEnv } = useOmlx(omlx)
-  const journal = createTauriJournalStore()
-  const kit = createAgentKit({ catalog, systemPrompt, transport, journal, actorTiers, grounding })
-
-  /**
-   * Build an omlx chat fn from the current config (tauri-http transport).
-   * @returns {(req: object) => Promise<object>} chat function
-   */
-  function chat() {
-    return createOpenAiChat({
-      baseUrl: baseUrl.value,
-      model: model.value,
-      apiKey: apiKey.value || undefined,
-      fetchFn: tauriFetch,
-    })
-  }
-
-  return {
-    baseUrl,
-    model,
-    apiKey,
-    saveOmlx: save,
-    loadOmlxEnv: loadEnv,
-    listModels: () => listOmlxModels({ baseUrl: baseUrl.value, apiKey: apiKey.value || undefined, fetchFn: tauriFetch }),
-    journal,
-    request: intent => kit.request({ intent, actor, chat: chat() }),
-    respond: (requestId, message) => kit.respond({ requestId, message, actor, chat: chat() }),
-    approve: (requestId, approve) => kit.approve({ requestId, approve }),
-  }
-}

package/src/vue/use-omlx.js

@@ -1,102 +0,0 @@
-import { ref } from 'vue'
-import { invoke } from '@tauri-apps/api/core'
-import { fetch as tauriFetch } from '@tauri-apps/plugin-http'
-import { isDirectOmlxUrl, resolveOmlxBaseUrlCached } from '../core/resolve-omlx-base-url.js'
-
-// Persisted config for the local omlx server (OpenAI-compatible MLX) that drives
-// the in-app agent. The API key / base URL come from Rust (omlx_config), which
-// reads them from ~/.omlx/settings.json — the same file the omlx server uses, so
-// the config is portable between machines without env/launchd setup. baseUrl is
-// edited in the dialog and cached in localStorage; omlx_config is the default
-// when localStorage is empty. Priority for base: localStorage > omlx_config >
-// hardcoded default. The key always comes from omlx_config.
-//
-// On top of that, when the resolved base is the default local :8000, loadEnv()
-// probes the myllm reverse proxy (:8088/health, cached with a short TTL) and
-// routes through it while it is alive — a runtime-only override that is never
-// persisted, so the dialog keeps showing/editing the direct URL and a custom
-// (non-:8000) base is never silently rerouted.
-//
-// storagePrefix namespaces the localStorage keys per app (so `task` and `mlmail`
-// keep independent base/model). defaults seed first launch.
-
-const DEFAULT_BASE_URL = 'http://127.0.0.1:8000/v1'
-
-/**
- * Read a localStorage value, or null when localStorage is unavailable
- * (component tests without a DOM store, SSR).
- * @param {string} key storage key
- * @returns {string|null} stored value, or null
- */
-function readStored(key) {
-  try {
-    return globalThis.localStorage?.getItem(key) ?? null
-  }
-  catch {
-    return null
-  }
-}
-
-/**
- * Write a localStorage value; no-op when localStorage is unavailable.
- * @param {string} key storage key
- * @param {string} value value to store
- */
-function writeStored(key, value) {
-  try {
-    globalThis.localStorage?.setItem(key, value)
-  }
-  catch {
-    // no localStorage (tests / SSR) — in-memory ref state is still updated
-  }
-}
-
-/**
- * @param {{ storagePrefix?: string, defaultBaseUrl?: string, defaultModel?: string }} [options] config
- * @returns {{ baseUrl: import('vue').Ref<string>, model: import('vue').Ref<string>, apiKey: import('vue').Ref<string>, save: () => void, loadEnv: () => Promise<void> }} persisted omlx config, an env loader and a saver
- */
-export function useOmlx({ storagePrefix = 'agent', defaultBaseUrl = DEFAULT_BASE_URL, defaultModel = '' } = {}) {
-  const baseUrlKey = `${storagePrefix}:omlxBaseUrl`
-  const modelKey = `${storagePrefix}:omlxModel`
-
-  const baseUrl = ref(readStored(baseUrlKey) || defaultBaseUrl)
-  const model = ref(readStored(modelKey) || defaultModel)
-  // Filled from the global env in loadEnv(); never persisted to localStorage.
-  const apiKey = ref('')
-
-  /**
-   * Pull OMLX_* from the user's global env (via Rust) and apply them: the API
-   * key is taken verbatim; baseUrl/model only fill in when localStorage is empty,
-   * so a value set in the dialog still wins. No-op outside Tauri (tests / web).
-   * @returns {Promise<void>}
-   */
-  async function loadEnv() {
-    let env
-    try {
-      env = await invoke('plugin:agent|omlx_config')
-    }
-    catch {
-      return // not running under Tauri — keep localStorage / defaults
-    }
-    if (env) {
-      if (env.apiKey) apiKey.value = env.apiKey
-      if (env.baseUrl && !readStored(baseUrlKey)) baseUrl.value = env.baseUrl
-      if (env.model && !readStored(modelKey)) model.value = env.model
-    }
-    // myllm proxy override — only for the default local target, runtime-only.
-    if (isDirectOmlxUrl(baseUrl.value)) {
-      baseUrl.value = await resolveOmlxBaseUrlCached({ directUrl: baseUrl.value, fetchFn: tauriFetch })
-    }
-  }
-
-  /**
-   * Persist baseUrl/model to localStorage. The API key is intentionally NOT
-   * persisted — it comes from the global OMLX_API_KEY env on each launch.
-   */
-  function save() {
-    writeStored(baseUrlKey, baseUrl.value)
-    writeStored(modelKey, model.value)
-  }
-
-  return { baseUrl, model, apiKey, save, loadEnv }
-}

package/types/core/agent-handler.d.ts

@@ -1,43 +0,0 @@
-/**
- * Start a new agent request.
- * @param {{ intent: string, actor: object, chat: Function, dispatch: Function, journal: object, tools: object[], gate: Function, buildSystem?: Function, grounding?: object }} opts request parameters
- * @returns {Promise<object>} structured result envelope
- */
-export function handleRequest({ intent, actor, chat, dispatch, journal, tools, gate, buildSystem, grounding }: {
-    intent: string;
-    actor: object;
-    chat: Function;
-    dispatch: Function;
-    journal: object;
-    tools: object[];
-    gate: Function;
-    buildSystem?: Function;
-    grounding?: object;
-}): Promise<object>;
-/**
- * Resume a conversation with a follow-up / clarification answer.
- * @param {{ requestId: string, message: string, actor: object, chat: Function, dispatch: Function, journal: object, tools: object[], gate: Function }} opts resume parameters
- * @returns {Promise<object>} updated result envelope
- */
-export function handleRespond({ requestId, message, chat, dispatch, journal, tools, gate }: {
-    requestId: string;
-    message: string;
-    actor: object;
-    chat: Function;
-    dispatch: Function;
-    journal: object;
-    tools: object[];
-    gate: Function;
-}): Promise<object>;
-/**
- * Approve (or reject) a pending destructive action. Executes with the approver's
- * (human) authority via the injected dispatch — no gate.
- * @param {{ requestId: string, approve: boolean, dispatch: Function, journal: object }} opts approval parameters
- * @returns {Promise<object>} updated result envelope
- */
-export function handleApprove({ requestId, approve, dispatch, journal }: {
-    requestId: string;
-    approve: boolean;
-    dispatch: Function;
-    journal: object;
-}): Promise<object>;

package/types/core/agent-kit.d.ts

@@ -1,30 +0,0 @@
-/**
- * @param {object} config kit configuration
- * @param {object[]} config.catalog tool definitions (required)
- * @param {string|((ctx: object) => string)} [config.systemPrompt] domain system prompt (or builder from grounding ctx)
- * @param {(tool: object, input: object) => unknown} [config.transport] backend runner; omit to build the kit without dispatch (manifest/scope only)
- * @param {object} [config.journal] journal store { create, load, update, list }
- * @param {Record<string, number>} [config.actorTiers] max executable tier rank per actor kind
- * @param {{ tool: string, key?: string, fallback?: unknown }} [config.grounding] optional read tool to ground the prompt
- * @returns {{ dispatch: Function|null, classify: Function, scopedManifest: Function, toolManifest: Function, request: Function, respond: Function, approve: Function }} bound kit
- */
-export function createAgentKit({ catalog, systemPrompt, transport, journal, actorTiers, grounding }?: {
-    catalog: object[];
-    systemPrompt?: string | ((ctx: object) => string) | undefined;
-    transport?: ((tool: object, input: object) => unknown) | undefined;
-    journal?: object | undefined;
-    actorTiers?: Record<string, number> | undefined;
-    grounding?: {
-        tool: string;
-        key?: string;
-        fallback?: unknown;
-    } | undefined;
-}): {
-    dispatch: Function | null;
-    classify: Function;
-    scopedManifest: Function;
-    toolManifest: Function;
-    request: Function;
-    respond: Function;
-    approve: Function;
-};

package/types/core/llm.d.ts

@@ -1,52 +0,0 @@
-/**
- * Run the tool-calling loop until the model answers without a tool call.
- * Accepts either a fresh prompt or an existing messages[] for sessional resume.
- * @param {object} params loop parameters
- * @param {string} [params.prompt] user request (fresh start)
- * @param {object[]} [params.messages] existing conversation to resume (takes priority over prompt)
- * @param {(name: string, input: object) => Promise<object>} params.dispatch tool dispatcher returning an envelope
- * @param {(req: {messages: object[], tools: object[]}) => Promise<object>} params.chat model call returning an assistant message
- * @param {number} [params.maxSteps] safety cap on loop iterations
- * @param {string} [params.system] system prompt (only used when building fresh from prompt)
- * @param {object[]} [params.tools] LLM tool manifest (pass a scoped manifest to restrict)
- * @param {(name: string) => 'allow'|'approval'|'deny'} [params.gate] per-call decision (default: allow)
- * @returns {Promise<{content: string, steps: number, trace: object[], messages: object[], stopped?: string, pendingApproval?: object}>} loop result
- */
-export function runAgent({ prompt, messages: initialMessages, dispatch, chat, maxSteps, system, tools, gate }: {
-    prompt?: string | undefined;
-    messages?: object[] | undefined;
-    dispatch: (name: string, input: object) => Promise<object>;
-    chat: (req: {
-        messages: object[];
-        tools: object[];
-    }) => Promise<object>;
-    maxSteps?: number | undefined;
-    system?: string | undefined;
-    tools?: object[] | undefined;
-    gate?: ((name: string) => "allow" | "approval" | "deny") | undefined;
-}): Promise<{
-    content: string;
-    steps: number;
-    trace: object[];
-    messages: object[];
-    stopped?: string;
-    pendingApproval?: object;
-}>;
-/**
- * Build a `chat` function that calls an OpenAI-compatible endpoint (omlx).
- * @param {object} params config
- * @param {string} params.baseUrl base URL incl. /v1 (e.g. http://127.0.0.1:10240/v1)
- * @param {string} params.model served model id
- * @param {string} [params.apiKey] optional bearer token
- * @param {typeof fetch} [params.fetchFn] fetch implementation (injectable for tests / tauri-http)
- * @returns {(req: {messages: object[], tools: object[]}) => Promise<object>} chat function
- */
-export function createOpenAiChat({ baseUrl, model, apiKey, fetchFn }: {
-    baseUrl: string;
-    model: string;
-    apiKey?: string | undefined;
-    fetchFn?: typeof fetch | undefined;
-}): (req: {
-    messages: object[];
-    tools: object[];
-}) => Promise<object>;

package/types/core/omlx-models.d.ts

@@ -1,17 +0,0 @@
-/**
- * @param {{ baseUrl?: string, apiKey?: string, fetchFn?: typeof fetch, signal?: AbortSignal }} [params] config
- * @returns {Promise<string[]>} loaded model ids (empty on error)
- */
-export function listOmlxModels({ baseUrl, apiKey, fetchFn, signal }?: {
-    baseUrl?: string;
-    apiKey?: string;
-    fetchFn?: typeof fetch;
-    signal?: AbortSignal;
-}): Promise<string[]>;
-/**
- * Pick a model: the preferred one if loaded, else the first available, else ''.
- * @param {string[]} models loaded model ids
- * @param {string} [preferred] preferred id
- * @returns {string} chosen model id
- */
-export function resolveModel(models: string[], preferred?: string): string;

package/types/core/resolve-omlx-base-url.d.ts

@@ -1,42 +0,0 @@
-/**
- * Is this URL the default local omlx server — the only target eligible for
- * the proxy override? A user who deliberately pointed an app at another
- * host/port must never be silently rerouted (the proxy's upstream is
- * hardwired to the local :8000).
- * @param {string} url candidate base URL
- * @returns {boolean} true for 127.0.0.1:8000 / localhost:8000, false otherwise (incl. parse errors)
- */
-export function isDirectOmlxUrl(url: string): boolean;
-/**
- * One-shot probe: GET {proxy origin}/health with a short timeout. 2xx means
- * the proxy (and omlx behind it) is alive → use the proxy; anything else
- * (timeout, refused, 502) → use the direct URL.
- * @param {{ directUrl?: string, proxyUrl?: string, fetchFn?: typeof fetch, timeoutMs?: number }} [params] config
- * @returns {Promise<string>} the base URL to use
- */
-export function resolveOmlxBaseUrl({ directUrl, proxyUrl, fetchFn, timeoutMs, }?: {
-    directUrl?: string;
-    proxyUrl?: string;
-    fetchFn?: typeof fetch;
-    timeoutMs?: number;
-}): Promise<string>;
-/**
- * Cached {@link resolveOmlxBaseUrl}: at most one probe per proxyUrl per TTL
- * window, so callers may resolve before every LLM call without paying the
- * probe latency each time, while still noticing the proxy starting/stopping
- * within one TTL.
- * @param {{ directUrl?: string, proxyUrl?: string, fetchFn?: typeof fetch, timeoutMs?: number, ttlMs?: number, now?: () => number }} [params] config
- * @returns {Promise<string>} the base URL to use
- */
-export function resolveOmlxBaseUrlCached({ ttlMs, now, ...probeOptions }?: {
-    directUrl?: string;
-    proxyUrl?: string;
-    fetchFn?: typeof fetch;
-    timeoutMs?: number;
-    ttlMs?: number;
-    now?: () => number;
-}): Promise<string>;
-/** Test hook: drop all cached probe results. */
-export function __resetOmlxBaseUrlCache(): void;
-export const DIRECT_OMLX_BASE_URL: "http://127.0.0.1:8000/v1";
-export const PROXY_OMLX_BASE_URL: "http://127.0.0.1:8088/v1";