@7n/tauri-components 0.6.0 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@7n/tauri-components",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "type": "module",
   "description": "Shared LLM agent engine + Vue/Quasar UI for Tauri apps (chat, journal, trust-tier approval).",
   "license": "MIT",

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

@@ -0,0 +1,84 @@
+// 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/index.js

@@ -8,6 +8,7 @@ export { handleApprove, handleRequest, handleRespond } from './core/agent-handle
 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'

package/src/vue/use-omlx.js

@@ -1,5 +1,7 @@
 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
@@ -9,6 +11,12 @@ import { invoke } from '@tauri-apps/api/core'
 // 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.
 
@@ -70,10 +78,15 @@ export function useOmlx({ storagePrefix = 'agent', defaultBaseUrl = DEFAULT_BASE
     catch {
       return // not running under Tauri — keep localStorage / defaults
     }
-    if (!env) return
-    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
+    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 })
+    }
   }
 
   /**

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

@@ -0,0 +1,42 @@
+/**
+ * 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";

package/types/index.d.ts

@@ -4,5 +4,6 @@ export { handleApprove, handleRequest, handleRespond } from "./core/agent-handle
 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";