@7n/tauri-components 0.10.1 → 0.11.0

package/src/core/agent-handler.js

@@ -1,171 +0,0 @@
-import { runAgent } from './llm.js'
-
-// Agent-gateway handlers — start / resume / approve the agent loop on behalf of a
-// caller (human via UI or agent via MCP). They own the journal lifecycle and
-// return a structured result contract.
-//
-// All collaborators are injected (no module-level singletons): `dispatch`,
-// `journal`, the scoped `tools` manifest, the `gate` decision fn, `buildSystem`
-// (turns optional grounding context into a system prompt) and `grounding` (an
-// optional read tool whose output grounds the prompt). createAgentKit wires
-// these from an app catalog; tests pass fakes.
-//
-// Trust: destructive tool calls from an agent pause as `needs_approval` (the
-// loop never executes them); a human approves later via handleApprove.
-
-const QUESTION_RE = /\?\s*$/
-
-/**
- * @param {string} text candidate text
- * @returns {boolean} true when text ends with a question mark
- */
-function isQuestion(text) {
-  return typeof text === 'string' && QUESTION_RE.test(text.trim())
-}
-
-/**
- * Derive the structured result fields from a runAgent result.
- * @param {object} result runAgent result
- * @returns {{ status: string, summary: string|null, question: string|null, pendingApproval: object|null }} fields
- */
-function finalize(result) {
-  const question = isQuestion(result.content) ? result.content : null
-  let status = 'done'
-  if (result.stopped === 'needs_approval') status = 'needs_approval'
-  else if (result.stopped === 'max_steps') status = 'partial'
-  else if (question) status = 'needs_clarification'
-  return {
-    status,
-    summary: question ? null : (result.content || null),
-    question,
-    pendingApproval: result.pendingApproval ?? null,
-  }
-}
-
-/**
- * Run the loop (fresh or resumed), persist to the journal, return the envelope.
- * @param {{ requestId: string, runArgs: object, baseActions: object[], journal: object }} ctx run context
- * @returns {Promise<object>} structured result envelope
- */
-async function runAndJournal({ requestId, runArgs, baseActions, journal }) {
-  let result
-  try {
-    result = await runAgent(runArgs)
-  }
-  catch (error) {
-    await journal.update(requestId, { status: 'failed', error: String(error?.message ?? error) })
-    return { requestId, status: 'failed', summary: null, actions: baseActions, question: null, pendingApproval: null }
-  }
-
-  const fields = finalize(result)
-  const actions = [...baseActions, ...result.trace]
-  await journal.update(requestId, { ...fields, messages: result.messages, actions })
-  return { requestId, ...fields, actions }
-}
-
-/**
- * Fetch optional grounding context via a read tool; {} when not configured / on failure.
- * @param {Function} dispatch tool dispatcher
- * @param {{ tool: string, key?: string, fallback?: unknown }} [grounding] grounding config
- * @returns {Promise<object>} context object keyed by grounding.key (default "grounding")
- */
-async function groundingContext(dispatch, grounding) {
-  if (!grounding?.tool) return {}
-  const key = grounding.key ?? 'grounding'
-  const fallback = grounding.fallback ?? []
-  try {
-    const res = await dispatch(grounding.tool, {})
-    return { [key]: res?.ok ? res.output : fallback }
-  }
-  catch {
-    return { [key]: fallback }
-  }
-}
-
-/**
- * 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 async function handleRequest({ intent, actor, chat, dispatch, journal, tools, gate, buildSystem, grounding }) {
-  const id = await journal.create({ intent, actor })
-  await journal.update(id, { status: 'running' })
-  const ctx = await groundingContext(dispatch, grounding)
-  const system = buildSystem ? buildSystem(ctx) : undefined
-  return runAndJournal({
-    requestId: id,
-    baseActions: [],
-    journal,
-    runArgs: { system, prompt: intent, chat, dispatch, tools, gate },
-  })
-}
-
-/**
- * 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 async function handleRespond({ requestId, message, chat, dispatch, journal, tools, gate }) {
-  let record
-  try {
-    record = await journal.load(requestId)
-  }
-  catch {
-    return { requestId, status: 'failed', summary: null, actions: [], question: 'Request not found.', pendingApproval: null }
-  }
-
-  if (record.status === 'running' || !Array.isArray(record.messages) || record.messages.length === 0) {
-    return { requestId, status: record.status, summary: record.summary, actions: record.actions, question: null, pendingApproval: record.pendingApproval ?? null }
-  }
-
-  await journal.update(requestId, { status: 'running' })
-  return runAndJournal({
-    requestId,
-    baseActions: record.actions ?? [],
-    journal,
-    runArgs: { messages: [...record.messages, { role: 'user', content: message }], chat, dispatch, tools, gate },
-  })
-}
-
-/**
- * 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 async function handleApprove({ requestId, approve, dispatch, journal }) {
-  let record
-  try {
-    record = await journal.load(requestId)
-  }
-  catch {
-    return { requestId, status: 'failed', summary: null, actions: [], question: 'Request not found.', pendingApproval: null }
-  }
-
-  if (record.status !== 'needs_approval' || !record.pendingApproval) {
-    return { requestId, status: record.status, summary: record.summary, actions: record.actions ?? [], question: null, pendingApproval: null }
-  }
-
-  if (!approve) {
-    const fields = { status: 'rejected', summary: 'Rejected by human.', pendingApproval: null }
-    await journal.update(requestId, fields)
-    return { requestId, ...fields, actions: record.actions ?? [], question: null }
-  }
-
-  const { tool, input } = record.pendingApproval
-  await journal.update(requestId, { status: 'running' })
-  const envelope = await dispatch(tool, input)
-  const actions = [...(record.actions ?? []), { tool, input, envelope }]
-
-  if (!envelope.ok) {
-    // Execution failed (e.g. transient) — stay needs_approval so the human can
-    // retry after fixing; keep pendingApproval, record the error and the attempt.
-    const error = envelope.error?.message ?? 'execution failed'
-    await journal.update(requestId, { status: 'needs_approval', actions, error })
-    return { requestId, status: 'needs_approval', summary: null, actions, error, question: null, pendingApproval: record.pendingApproval }
-  }
-
-  const summary = `Approved: ${tool} executed.`
-  await journal.update(requestId, { status: 'done', actions, summary, error: null, pendingApproval: null })
-  return { requestId, status: 'done', summary, actions, question: null, pendingApproval: null }
-}

package/src/core/agent-kit.js

@@ -1,43 +0,0 @@
-import { handleApprove, handleRequest, handleRespond } from './agent-handler.js'
-import { createDispatch } from './dispatch.js'
-import { toolManifest } from './manifest.js'
-import { classify, DEFAULT_ACTOR_TIERS, scopedManifest } from './scope.js'
-
-// createAgentKit binds the generic agent machinery to ONE app's tool catalog.
-// It is the single integration seam: an app supplies its catalog, a domain
-// system prompt, a transport (Tauri invoke / CLI spawn / fetch), a journal store
-// and optional grounding, and gets back request/respond/approve plus the derived
-// manifest + scope helpers — all pre-bound, so callers never re-thread the
-// catalog. The `chat` fn stays per-call (its config can change between requests).
-
-/**
- * @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 = DEFAULT_ACTOR_TIERS, grounding } = {}) {
-  if (!Array.isArray(catalog)) throw new Error('createAgentKit: catalog (array) is required')
-
-  const dispatch = transport ? createDispatch(catalog, transport) : null
-  const buildSystem = typeof systemPrompt === 'function' ? systemPrompt : () => systemPrompt
-  const toolsFor = actor => scopedManifest(catalog, actorTiers, actor)
-  const gateFor = actor => name => classify(catalog, actorTiers, actor, name)
-
-  return {
-    dispatch,
-    classify: (actor, name) => classify(catalog, actorTiers, actor, name),
-    scopedManifest: actor => toolsFor(actor),
-    toolManifest: allow => toolManifest(catalog, allow),
-    request: ({ intent, actor, chat }) =>
-      handleRequest({ intent, actor, chat, dispatch, journal, tools: toolsFor(actor), gate: gateFor(actor), buildSystem, grounding }),
-    respond: ({ requestId, message, actor, chat }) =>
-      handleRespond({ requestId, message, actor, chat, dispatch, journal, tools: toolsFor(actor), gate: gateFor(actor) }),
-    approve: ({ requestId, approve }) =>
-      handleApprove({ requestId, approve, dispatch, journal }),
-  }
-}

package/src/core/docs/agent-handler.md

@@ -1,31 +0,0 @@
----
-docgen:
-  source: npm/src/core/agent-handler.js
-  crc: 8ef1230c
-  model: omlx/gemma-4-e4b-it-OptiQ-4bit
-  score: 100
-  issues: judge:inaccurate:0.97
-  judgeModel: openai-codex/gpt-5.4-mini
----
-
-# agent-handler.js
-
-## Огляд
-
-Модуль керує життєвим циклом агентського запиту. Він ініціює запит через `handleRequest`, підтримує діалог з користувачем через `handleRespond` та реалізує логіку схвалення через `handleApprove`.
-
-## Поведінка
-
-handleRequest ініціює новий агентський запит, створює запис у журналі та запускає цикл агента.
-handleRespond продовжує розмову, використовуючи попередній стан запису та нове повідомлення користувача.
-handleApprove виконує або відхиляє заплановану деструктивну дію, якщо запис перебуває у стані очікування схвалення.
-
-## Публічний API
-
-handleRequest — Ініціює новий запит до агента.
-handleRespond — Продовжує діалог, надаючи відповідь або уточнення.
-handleApprove — Підтверджує (або відхиляє) заплановану руйнівну дію, виконуючи її з дозволу користувача.
-
-## Гарантії поведінки
-
-- Перехоплює помилки і не пропускає винятків назовні (fail-safe).

package/src/core/docs/agent-kit.md

@@ -1,25 +0,0 @@
----
-docgen:
-  source: npm/src/core/agent-kit.js
-  crc: 27461b4b
-  model: omlx/gemma-4-e4b-it-OptiQ-4bit
-  score: 100
-  judgeModel: openai-codex/gpt-5.4-mini
----
-
-# agent-kit.js
-
-## Огляд
-
-Цей модуль відповідає за ініціалізацію та конфігурування набору інструментів для агента. Функція `createAgentKit` створює об'єкт, що містить необхідні методи та механізми для роботи агента, забезпечуючи його доступ до інструментів та системних налаштувань.
-
-## Поведінка
-
-1. Викликати `createAgentKit` для створення набору інструментів агента.
-2. Надати `createAgentKit` каталог інструментів.
-3. За бажанням надати системний підказку, транспортний механізм, сховище журналу, рівні акторів та інструмент для заземлення.
-4. Отримати об'єкт набору інструментів, що містить функції для диспетчеризації, класифікації, отримання маніфесту інструментів, створення запитів, відповідей та схвалення.
-
-## Гарантії поведінки
-
-- (специфічних машинно-виведених гарантій немає)

package/src/core/docs/llm.md

@@ -1,29 +0,0 @@
----
-docgen:
-  source: npm/src/core/llm.js
-  crc: 2f379651
-  model: omlx/gemma-4-e4b-it-OptiQ-4bit
-  score: 100
-  issues: judge:inaccurate:0.98
-  judgeModel: openai-codex/gpt-5.4-mini
----
-
-# llm.js
-
-## Огляд
-
-Модуль дозволяє ініціювати сеанс чату з мовною моделлю через мережевий ендпоінт <http://127.0.0.1:10240/v1>. Функціонал реалізується через публічні функції `runAgent` та `createOpenAiChat`. Код виконує виклик API та керує циклом виклику інструментів у контексті агента, доки модель не надасть фінальну відповідь або не буде перевищено ліміт кроків. Робота залежить від конфігурації, описаної у `response.json`.
-
-## Поведінка
-
-runAgent виконує цикл виклику інструментів, поки модель не надасть відповідь без виклику інструменту, або доки не буде досягнуто максимальної кількості кроків.
-createOpenAiChat створює функцію, яка викликає мережевий ендпоінт OpenAI-сумісного API (наприклад, <http://127.0.0.1:10240/v1>) для отримання відповіді моделі.
-
-## Публічний API
-
-runAgent — Запускає цикл виклику інструментів до моменту, коли модель надає відповідь без виклику інструменту. Може використовувати новий запит або продовжувати сесію на основі існуючої історії повідомлень.
-createOpenAiChat — Створює функцію для взаємодії з кінцевою точкою, сумісною з OpenAI (omlx).
-
-## Гарантії поведінки
-
-- Read-only: не виконує операцій запису (ФС/БД).

package/src/core/docs/omlx-models.md

@@ -1,30 +0,0 @@
----
-docgen:
-  source: npm/src/core/omlx-models.js
-  crc: 81a5dc3a
-  model: omlx/gemma-4-e4b-it-OptiQ-4bit
-  score: 100
-  issues: judge:inaccurate:0.97
-  judgeModel: openai-codex/gpt-5.4-mini
----
-
-# omlx-models.js
-
-## Огляд
-
-Модуль надає публічні механізми для взаємодії з локально завантаженими моделями. Він дозволяє отримати повний список доступних моделей та вибрати конкретну модель із цього списку. Функціонал працює в режимі, що перехоплює помилки (fail-safe), і не здійснює запису у файлову систему чи бази даних. Робота модуля залежить від конфігурацій, зокрема `response.json`.
-
-## Поведінка
-
-listOmlxModels отримує список ідентифікаторів моделей, завантажених локальним сервером, або повертає порожній масив у разі будь-якої помилки.
-resolveModel обирає модель з наданого списку, надаючи пріоритет обраній моделі, або повертає першу доступну модель, якщо пріоритетна відсутня.
-
-## Публічний API
-
-listOmlxModels — отримує список доступних моделей.
-resolveModel — вибирає модель: обрану, якщо вона завантажена, інакше першу доступну, або порожній рядок.
-
-## Гарантії поведінки
-
-- Read-only: не виконує операцій запису (ФС/БД).
-- Перехоплює помилки і не пропускає винятків назовні (fail-safe).

package/src/core/docs/resolve-omlx-base-url.md

@@ -1,40 +0,0 @@
----
-docgen:
-  source: npm/src/core/resolve-omlx-base-url.js
-  crc: 36c282c7
-  model: omlx/gemma-4-e4b-it-OptiQ-4bit
-  score: 100
-  issues: judge:inaccurate:0.99
-  judgeModel: openai-codex/gpt-5.4-mini
----
-
-# resolve-omlx-base-url.js
-
-## Огляд
-
-Модуль визначає та надає базові URL для взаємодії з серверами omlx. Він експортує константи: DIRECT_OMLX_BASE_URL="<http://127.0.0.1:8000/v1>" для прямого доступу та PROXY_OMLX_BASE_URL="<http://127.0.0.1:8088/v1>" для проксі-доступу. Модуль звертається до мережі для визначення робочого URL, перевіряючи доступність проксі-сервера. Вибір URL кешується у межах прогону. При помилках мережевого доступу модуль перехоплює їх (fail-safe) і повертає порожнє значення замість кидання винятків. Модуль є лише для читання (не виконує операцій з ФС/БД).
-
-## Поведінка
-
-DIRECT_OMLX_BASE_URL: Надає базовий URL для прямого доступу до сервера omlx, який є <http://127.0.0.1:8000/v1>.
-PROXY_OMLX_BASE_URL: Надає базовий URL для доступу через проксі-сервер omlx, який є <http://127.0.0.1:8088/v1>.
-isDirectOmlxUrl: Перевіряє, чи вказаний URL є стандартним локальним сервером omlx (<http://127.0.0.1:8000> або localhost:8000).
-resolveOmlxBaseUrl: Визначає ефективний базовий URL omlx, перевіряючи доступність проксі-сервера через зондування `/health`; у разі успіху повертає URL проксі, інакше — прямий URL.
-resolveOmlxBaseUrlCached: Визначає ефективний базовий URL omlx, використовуючи кешування для уникнення повторних зондувань протягом заданого часу життя (TTL).
-__resetOmlxBaseUrlCache: Очищає кеш результатів зондування базового URL omlx.
-
-## Публічний API
-
-DIRECT_OMLX_BASE_URL — Базовий URL для прямого доступу до локального OMLX сервера, що вказує на <http://127.0.0.1:8000/v1>.
-PROXY_OMLX_BASE_URL — Базовий URL для проксі-доступу до OMLX сервера, що вказує на <http://127.0.0.1:8088/v1>.
-isDirectOmlxUrl — Визначає, чи є URL основним локальним сервером OMLX, який не повинен бути перенаправлений через проксі.
-resolveOmlxBaseUrl — Перевіряє доступність проксі-сервера шляхом виконання GET-запиту до <http://127.0.0.1:8088/v1>; якщо відповідь успішна, використовується проксі, інакше — прямий URL.
-resolveOmlxBaseUrlCached — Виконує перевірку доступності проксі-сервера з кешуванням, щоб уникнути повторних перевірок при кожному виклику LLM.
-__resetOmlxBaseUrlCache — Очищає всі збережені результати перевірки доступності базового URL OMLX.
-
-## Гарантії поведінки
-
-- Read-only: не виконує операцій запису (ФС/БД).
-- Перехоплює помилки і не пропускає винятків назовні (fail-safe).
-- За певних помилок повертає порожнє значення (напр. `null`) замість винятку.
-- Кешує результати в межах одного прогону.

package/src/core/llm.js

@@ -1,90 +0,0 @@
-// The tool-calling loop and an OpenAI-compatible chat adapter. Both are
-// stateless and domain-agnostic: the system prompt and tool manifest are passed
-// in by the caller (an app builds them from its catalog — see agent-kit.js).
-
-const DEFAULT_SYSTEM = 'You are a tool-using assistant. Call one tool at a time and wait for its result. If the request is ambiguous, ask a clarifying question with no tool call. When done, reply with a plain-text summary and no tool call.'
-
-/**
- * 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 async function runAgent({ prompt, messages: initialMessages, dispatch, chat, maxSteps = 6, system = DEFAULT_SYSTEM, tools = [], gate = () => 'allow' }) {
-  const messages = initialMessages
-    ? [...initialMessages]
-    : [
-        { role: 'system', content: system },
-        { role: 'user', content: prompt },
-      ]
-  const trace = []
-
-  for (let step = 0; step < maxSteps; step++) {
-    const reply = await chat({ messages, tools })
-    messages.push(reply)
-
-    const calls = reply.tool_calls ?? []
-    if (calls.length === 0) {
-      return { content: reply.content ?? '', steps: step + 1, trace, messages }
-    }
-
-    for (const call of calls) {
-      let input = {}
-      try {
-        input = call.function.arguments ? JSON.parse(call.function.arguments) : {}
-      }
-      catch {
-        // leave input empty — dispatch's schema validation reports the problem
-      }
-
-      const decision = gate(call.function.name)
-      if (decision === 'approval') {
-        // Destructive request from a non-human: pause for human approval.
-        return { content: reply.content ?? '', steps: step + 1, trace, messages, stopped: 'needs_approval', pendingApproval: { tool: call.function.name, input } }
-      }
-
-      const envelope = decision === 'deny'
-        ? { ok: false, error: { code: 'forbidden', message: `Tool "${call.function.name}" is not allowed.` } }
-        : await dispatch(call.function.name, input)
-      trace.push({ tool: call.function.name, input, envelope })
-      messages.push({ role: 'tool', tool_call_id: call.id, content: JSON.stringify(envelope) })
-    }
-  }
-
-  return { content: '', steps: maxSteps, trace, messages, stopped: 'max_steps' }
-}
-
-/**
- * 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 = fetch }) {
-  return async function chat({ messages, tools }) {
-    const response = await fetchFn(`${baseUrl}/chat/completions`, {
-      method: 'POST',
-      headers: {
-        'content-type': 'application/json',
-        ...(apiKey ? { authorization: `Bearer ${apiKey}` } : {}),
-      },
-      body: JSON.stringify({ model, messages, tools, tool_choice: 'auto' }),
-    })
-    if (!response.ok) {
-      throw new Error(`omlx ${response.status}: ${await response.text()}`)
-    }
-    const data = await response.json()
-    return data.choices[0].message
-  }
-}

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`) замість винятку.
-- Кешує результати в межах одного прогону.