faces-cli 1.6.18 → 1.7.1

package/dist/routing.d.ts

@@ -0,0 +1,19 @@
+import { FacesClient } from './client.js';
+export declare const MESSAGES_ENDPOINT = "/v1/messages";
+export declare const RESPONSES_ENDPOINT = "/v1/responses";
+export declare const CHAT_COMPLETIONS_ENDPOINT = "/v1/chat/completions";
+export interface RouteInfo {
+    endpoint: string;
+    /** The resolved LLM id we routed on (undefined if it couldn't be determined). */
+    llm?: string;
+    /** True when a free (OAuth-subscription) variant of this model exists in the catalog. */
+    freeWhenConnected: boolean;
+}
+/** Split `alias@llm` → llm; bare `alias` → undefined. */
+export declare function llmFromArg(modelArg: string): string | undefined;
+/**
+ * Decide which API endpoint a chat request should be posted to, driven entirely
+ * by the model catalog (GET /v1/models). For a bare alias we resolve the face's
+ * default model from the local catalog, falling back to GET /v1/faces/{alias}.
+ */
+export declare function resolveEndpoint(client: FacesClient, modelArg: string): Promise<RouteInfo>;

package/dist/routing.js

@@ -0,0 +1,116 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { CATALOG_INDEX } from './catalog.js';
+export const MESSAGES_ENDPOINT = '/v1/messages';
+export const RESPONSES_ENDPOINT = '/v1/responses';
+export const CHAT_COMPLETIONS_ENDPOINT = '/v1/chat/completions';
+const CACHE_PATH = path.join(os.homedir(), '.faces', 'models-cache.json');
+const TTL_MS = 60 * 60 * 1000; // 1 hour
+/** Last-resort routing when the catalog can't tell us where a model lives. */
+function fallbackEndpoint(llm) {
+    if (llm && llm.startsWith('claude'))
+        return MESSAGES_ENDPOINT;
+    return CHAT_COMPLETIONS_ENDPOINT;
+}
+function readCache() {
+    try {
+        return JSON.parse(fs.readFileSync(CACHE_PATH, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function writeCache(models) {
+    try {
+        const dir = path.dirname(CACHE_PATH);
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        fs.writeFileSync(CACHE_PATH, JSON.stringify({ fetched_at: Date.now(), models }), { mode: 0o600 });
+    }
+    catch {
+        // a cache write failure is non-fatal
+    }
+}
+async function fetchModels(client) {
+    const raw = (await client.get('/v1/models'));
+    const data = Array.isArray(raw) ? raw : (raw.data ?? raw.models ?? []);
+    return data;
+}
+/**
+ * Return the list of catalog models, served from a short-lived on-disk cache.
+ * Falls back to a stale cache if the network fetch fails, and to an empty list
+ * if there's nothing cached — callers degrade to {@link fallbackEndpoint}.
+ */
+async function getModels(client) {
+    const cache = readCache();
+    if (cache && Date.now() - cache.fetched_at < TTL_MS)
+        return cache.models;
+    try {
+        const models = await fetchModels(client);
+        writeCache(models);
+        return models;
+    }
+    catch {
+        return cache?.models ?? [];
+    }
+}
+/** Build an id → {endpoint, freeWhenConnected} map, deduping paid/oauth twins. */
+function buildMap(models) {
+    const map = new Map();
+    for (const m of models) {
+        if (!m.id || !m.endpoint)
+            continue;
+        const existing = map.get(m.id);
+        const isOauth = m.provider === 'openai_oauth';
+        if (existing) {
+            existing.freeWhenConnected = existing.freeWhenConnected || isOauth;
+        }
+        else {
+            map.set(m.id, { endpoint: m.endpoint, freeWhenConnected: isOauth });
+        }
+    }
+    return map;
+}
+/** Read a face's default_model from the local catalog index without a network call. */
+function defaultModelFromCatalog(alias) {
+    try {
+        const entries = JSON.parse(fs.readFileSync(CATALOG_INDEX, 'utf8'));
+        const hit = entries.find((e) => e.alias === alias);
+        return hit?.default_model || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Split `alias@llm` → llm; bare `alias` → undefined. */
+export function llmFromArg(modelArg) {
+    const i = modelArg.lastIndexOf('@');
+    return i >= 0 ? modelArg.slice(i + 1) : undefined;
+}
+/**
+ * Decide which API endpoint a chat request should be posted to, driven entirely
+ * by the model catalog (GET /v1/models). For a bare alias we resolve the face's
+ * default model from the local catalog, falling back to GET /v1/faces/{alias}.
+ */
+export async function resolveEndpoint(client, modelArg) {
+    let llm = llmFromArg(modelArg);
+    if (!llm) {
+        const alias = modelArg.split('@')[0];
+        llm = defaultModelFromCatalog(alias);
+        if (!llm) {
+            try {
+                const face = (await client.get(`/v1/faces/${encodeURIComponent(alias)}`));
+                llm = face.default_model || undefined;
+            }
+            catch {
+                // fall through to heuristic
+            }
+        }
+    }
+    const map = buildMap(await getModels(client));
+    const hit = llm ? map.get(llm) : undefined;
+    if (hit)
+        return { endpoint: hit.endpoint, llm, freeWhenConnected: hit.freeWhenConnected };
+    return { endpoint: fallbackEndpoint(llm), llm, freeWhenConnected: false };
+}