@7n/tauri-components 0.10.1 → 0.11.0

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";