@7n/tauri-components 0.10.1 → 0.11.1

package/src/vue/use-updater.js

@@ -45,14 +45,13 @@ export function useUpdater() {
         message: `Версія ${update.version} готова. Встановити зараз?`,
         cancel: { label: 'Пізніше', flat: true },
         ok: { label: 'Встановити', color: 'primary' },
-        persistent: true,
+        persistent: true
       })
         .onOk(() => installAndRelaunch(update))
         .onCancel(() => {
           busy = false
         })
-    }
-    catch (error) {
+    } catch (error) {
       // No network, or the updater isn't configured/permitted — don't bother
       // the user, but leave a trace for diagnosis.
       console.error('[updater] check failed:', error)
@@ -94,10 +93,9 @@ export function useUpdater() {
         message: `Перезапустити зараз, щоб перейти на версію ${update.version}?`,
         cancel: { label: 'Пізніше', flat: true },
         ok: { label: 'Перезапустити', color: 'primary' },
-        persistent: true,
+        persistent: true
       }).onOk(() => relaunch())
-    }
-    catch (error) {
+    } catch (error) {
       dismiss()
       busy = false
       console.error('[updater] install failed:', error)

package/types/core/dispatch.d.ts

@@ -4,11 +4,14 @@
  * @param {object} [input] candidate input
  * @returns {string|null} error message, or null when valid
  */
-export function validateInput(tool: object, input?: object): string | null;
+export function validateInput(tool: object, input?: object): string | null
 /**
  * Build a dispatch function bound to a catalog and a transport.
  * @param {object[]} catalog tool definitions
  * @param {(tool: object, input: object) => unknown} transport runs the tool's backend call
  * @returns {(name: string, input?: object) => Promise<object>} dispatch returning an envelope
  */
-export function createDispatch(catalog: object[], transport: (tool: object, input: object) => unknown): (name: string, input?: object) => Promise<object>;
+export function createDispatch(
+  catalog: object[],
+  transport: (tool: object, input: object) => unknown
+): (name: string, input?: object) => Promise<object>

package/types/core/manifest.d.ts

@@ -3,24 +3,29 @@
  * @param {Record<string, {type: string, required?: boolean, description?: string}>} input tool input spec
  * @returns {object} JSON Schema for the parameters object
  */
-export function toJsonSchema(input: Record<string, {
-    type: string;
-    required?: boolean;
-    description?: string;
-}>): object;
+export function toJsonSchema(
+  input: Record<
+    string,
+    {
+      type: string
+      required?: boolean
+      description?: string
+    }
+  >
+): object
 /**
  * OpenAI function-calling tool definitions, optionally filtered (e.g. by scope).
  * @param {object[]} catalog tool definitions
  * @param {(tool: object) => boolean} [allow] predicate; default includes all tools
  * @returns {object[]} OpenAI `tools` array
  */
-export function toolManifest(catalog: object[], allow?: (tool: object) => boolean): object[];
+export function toolManifest(catalog: object[], allow?: (tool: object) => boolean): object[]
 /**
  * Compact catalog listing (name + summary).
  * @param {object[]} catalog tool definitions
  * @returns {{name: string, summary: string}[]} tool list
  */
 export function listTools(catalog: object[]): {
-    name: string;
-    summary: string;
-}[];
+  name: string
+  summary: string
+}[]

package/types/core/scope.d.ts

@@ -6,9 +6,14 @@
  * @param {string} toolName tool name
  * @returns {'allow'|'approval'|'deny'} decision
  */
-export function classify(catalog: object[], actorTiers: Record<string, number> | undefined, actor: {
-    kind?: string;
-}, toolName: string): "allow" | "approval" | "deny";
+export function classify(
+  catalog: object[],
+  actorTiers: Record<string, number> | undefined,
+  actor: {
+    kind?: string
+  },
+  toolName: string
+): 'allow' | 'approval' | 'deny'
 /**
  * LLM tool manifest visible to the actor (everything it may run OR request approval for).
  * @param {object[]} catalog tool definitions
@@ -16,9 +21,13 @@ export function classify(catalog: object[], actorTiers: Record<string, number> |
  * @param {{ kind?: string }} actor caller identity
  * @returns {object[]} OpenAI tools array
  */
-export function scopedManifest(catalog: object[], actorTiers: Record<string, number> | undefined, actor: {
-    kind?: string;
-}): object[];
+export function scopedManifest(
+  catalog: object[],
+  actorTiers: Record<string, number> | undefined,
+  actor: {
+    kind?: string
+  }
+): object[]
 /**
  * Tool names visible to the actor.
  * @param {object[]} catalog tool definitions
@@ -26,10 +35,14 @@ export function scopedManifest(catalog: object[], actorTiers: Record<string, num
  * @param {{ kind?: string }} actor caller identity
  * @returns {string[]} visible tool names
  */
-export function scopedToolNames(catalog: object[], actorTiers: Record<string, number> | undefined, actor: {
-    kind?: string;
-}): string[];
+export function scopedToolNames(
+  catalog: object[],
+  actorTiers: Record<string, number> | undefined,
+  actor: {
+    kind?: string
+  }
+): string[]
 export namespace DEFAULT_ACTOR_TIERS {
-    let human: number;
-    let agent: number;
+  let human: number
+  let agent: number
 }

package/types/core/tools.d.ts

@@ -4,4 +4,4 @@
  * @param {string} name tool name
  * @returns {object|null} the tool definition, or null if unknown
  */
-export function getTool(catalog: object[], name: string): object | null;
+export function getTool(catalog: object[], name: string): object | null

package/types/index.d.ts

@@ -1,9 +1,4 @@
-export { createAgentKit } from "./core/agent-kit.js";
-export { getTool } from "./core/tools.js";
-export { handleApprove, handleRequest, handleRespond } from "./core/agent-handler.js";
-export { createDispatch, validateInput } from "./core/dispatch.js";
-export { createOpenAiChat, runAgent } from "./core/llm.js";
-export { listOmlxModels, resolveModel } from "./core/omlx-models.js";
-export { DIRECT_OMLX_BASE_URL, isDirectOmlxUrl, PROXY_OMLX_BASE_URL, resolveOmlxBaseUrl, resolveOmlxBaseUrlCached } from "./core/resolve-omlx-base-url.js";
-export { listTools, toJsonSchema, toolManifest } from "./core/manifest.js";
-export { classify, DEFAULT_ACTOR_TIERS, scopedManifest, scopedToolNames } from "./core/scope.js";
+export { getTool } from './core/tools.js'
+export { createDispatch, validateInput } from './core/dispatch.js'
+export { listTools, toJsonSchema, toolManifest } from './core/manifest.js'
+export { classify, DEFAULT_ACTOR_TIERS, scopedManifest, scopedToolNames } from './core/scope.js'

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
-  }
-}