@visual-z/xeno 0.8.4 → 0.9.1

package/src/runtime/model-discovery.ts

@@ -1,208 +0,0 @@
-/**
- * Live model discovery: ask the provider which models this key can use.
- *
- * Wire vocabulary (URLs, auth headers, response shapes) belongs to runtime,
- * not the SDK-free core (D13). Everything except `discoverModels` is pure so
- * the URL and parsing rules are unit tested without a network.
- *
- * Endpoints, per the vendors' own list APIs and what magpie / CC Switch /
- * Crush converged on (docs/tasks/feat-provider-connect.md):
- *   OpenAI-compatible  GET {base}/models                Authorization: Bearer
- *   Anthropic          GET {root}/v1/models             x-api-key + anthropic-version
- *                      (paged: has_more / last_id → ?after_id=)
- *   Gemini             GET {base}/models                x-goog-api-key
- *                      (paged: nextPageToken → ?pageToken=; keep generateContent)
- *
- * A pasted full endpoint (…/chat/completions, …/v1/messages) is cut back to
- * its base, and a base without a version segment also tries `/v1`, because
- * gateways disagree on where the version lives. Anthropic-compatible
- * gateways often want Bearer instead of x-api-key; both are sent (magpie).
- */
-import type { ProviderApi } from "./provider-protocols.ts";
-
-export type DiscoveryFamily = "openai" | "anthropic" | "google";
-
-export interface DiscoveredModel {
-  id: string;
-  name?: string;
-  contextWindow?: number;
-  maxTokens?: number;
-}
-
-export type DiscoveryResult =
-  | { ok: true; models: DiscoveredModel[]; url: string }
-  | { ok: false; reason: string; status?: number };
-
-export function discoveryFamily(api: ProviderApi): DiscoveryFamily | undefined {
-  switch (api) {
-    case "openai-completions":
-    case "openai-responses":
-    case "mistral-conversations":
-      return "openai";
-    case "anthropic-messages":
-      return "anthropic";
-    case "google-generative-ai":
-      return "google";
-    default:
-      // Vertex, Bedrock, Azure, Codex and Pi need cloud auth or have no
-      // listing endpoint; their catalog entries stay authoritative.
-      return undefined;
-  }
-}
-
-const ENDPOINT_SUFFIXES = [/\/chat\/completions\/?$/, /\/responses\/?$/, /\/completions\/?$/, /\/messages\/?$/, /\/models\/?$/];
-
-/** Strip whitespace, trailing slashes and a pasted operation path. */
-export function normalizeBaseUrl(raw: string): string {
-  let url = raw.trim().replace(/\/+$/, "");
-  for (const suffix of ENDPOINT_SUFFIXES) url = url.replace(suffix, "");
-  return url.replace(/\/+$/, "");
-}
-
-const VERSIONED = /\/v\d+(beta\d*|alpha\d*)?$/;
-
-export function discoveryUrls(family: DiscoveryFamily, baseUrl: string): string[] {
-  const base = normalizeBaseUrl(baseUrl);
-  const urls: string[] = [];
-  const add = (url: string) => { if (!urls.includes(url)) urls.push(url); };
-  switch (family) {
-    case "openai":
-      add(`${base}/models`);
-      if (!VERSIONED.test(base)) add(`${base}/v1/models`);
-      break;
-    case "anthropic": {
-      const root = base.replace(/\/v1$/, "");
-      add(`${root}/v1/models`);
-      add(`${base}/models`);
-      break;
-    }
-    case "google":
-      add(VERSIONED.test(base) ? `${base}/models` : `${base}/v1beta/models`);
-      break;
-  }
-  return urls;
-}
-
-export function discoveryHeaders(family: DiscoveryFamily, key: string): Record<string, string> {
-  if (key.length === 0) return {};
-  switch (family) {
-    case "openai": return { authorization: `Bearer ${key}` };
-    case "anthropic": return { "x-api-key": key, authorization: `Bearer ${key}`, "anthropic-version": "2023-06-01" };
-    case "google": return { "x-goog-api-key": key };
-  }
-}
-
-function record(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function positive(value: unknown): number | undefined {
-  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
-}
-function text(value: unknown): string | undefined {
-  return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
-}
-
-/** One page of a list response. `next` is the query to append for the following page. */
-export function parseModelPage(family: DiscoveryFamily, json: unknown): { models: DiscoveredModel[]; next?: string } {
-  if (!record(json)) return { models: [] };
-  const rows = Array.isArray(json["data"]) ? json["data"] : Array.isArray(json["models"]) ? json["models"] : [];
-  const models: DiscoveredModel[] = [];
-  for (const row of rows) {
-    if (!record(row)) continue;
-    if (family === "google") {
-      const methods = row["supportedGenerationMethods"];
-      if (Array.isArray(methods) && !methods.includes("generateContent")) continue;
-      const id = text(row["name"])?.replace(/^models\//, "") ?? text(row["id"]);
-      if (!id) continue;
-      models.push(compact({ id, name: text(row["displayName"]), contextWindow: positive(row["inputTokenLimit"]), maxTokens: positive(row["outputTokenLimit"]) }));
-      continue;
-    }
-    const id = text(row["id"]) ?? text(row["name"]);
-    if (!id) continue;
-    // OpenRouter and several gateways publish limits on the listing itself.
-    const top = record(row["top_provider"]) ? row["top_provider"] : {};
-    models.push(compact({
-      id,
-      name: text(row["display_name"]) ?? (text(row["name"]) !== id ? text(row["name"]) : undefined),
-      contextWindow: positive(row["context_length"]) ?? positive(row["context_window"]) ?? positive(top["context_length"]),
-      maxTokens: positive(row["max_output_tokens"]) ?? positive(top["max_completion_tokens"]),
-    }));
-  }
-  if (family === "anthropic" && json["has_more"] === true && text(json["last_id"])) return { models, next: `after_id=${encodeURIComponent(String(json["last_id"]))}` };
-  if (family === "google" && text(json["nextPageToken"])) return { models, next: `pageToken=${encodeURIComponent(String(json["nextPageToken"]))}` };
-  return { models };
-}
-
-function compact(model: { id: string; name: string | undefined; contextWindow: number | undefined; maxTokens: number | undefined }): DiscoveredModel {
-  return { id: model.id, ...(model.name !== undefined ? { name: model.name } : {}),
-    ...(model.contextWindow !== undefined ? { contextWindow: model.contextWindow } : {}),
-    ...(model.maxTokens !== undefined ? { maxTokens: model.maxTokens } : {}) };
-}
-
-/**
- * `/models` on OpenAI-style endpoints also lists embeddings, speech, image and
- * moderation models. They can never run a coding turn, so the picker should
- * not offer them. Pattern list, not a guess per model: ids that match are
- * still shown in the wizard under "other", just not preselected.
- */
-const NON_CHAT = /(^|[-_/.:])(embed|embedding|embeddings|tts|whisper|transcribe|dall-e|dalle|moderation|image|imagen|audio|realtime|speech|rerank|reranker|search|veo|sora|davinci|babbage)([-_/.:]|\d|$)/i;
-export function likelyChatModel(id: string): boolean {
-  return !NON_CHAT.test(id);
-}
-
-/**
- * Network IO. Candidates are tried in order; 404/405 moves on, an auth
- * failure stops (another URL will not make a wrong key right), and any
- * other failure is reported with the URL that produced it.
- * Timeout 10s per request: assumed; long enough for a slow gateway's first
- * response, short enough that a dead host is reported while the user waits.
- */
-const DISCOVERY_TIMEOUT_MS = 10_000;
-/** Pagination bound: Anthropic pages at 20 by default; 25 pages covers every known list. Assumed. */
-const MAX_PAGES = 25;
-
-export async function discoverModels(opts: {
-  family: DiscoveryFamily;
-  baseUrl: string;
-  key: string;
-  headers?: Record<string, string>;
-  fetch: (input: string, init?: RequestInit) => Promise<Response>;
-  signal?: AbortSignal;
-  timeoutMs?: number;
-}): Promise<DiscoveryResult> {
-  const headers = { accept: "application/json", ...discoveryHeaders(opts.family, opts.key), ...opts.headers };
-  let last: DiscoveryResult = { ok: false, reason: "no discovery URL" };
-  for (const url of discoveryUrls(opts.family, opts.baseUrl)) {
-    const models: DiscoveredModel[] = [];
-    let query: string | undefined;
-    let failed: DiscoveryResult | undefined;
-    for (let page = 0; page < MAX_PAGES; page++) {
-      const target = query ? `${url}${url.includes("?") ? "&" : "?"}${query}` : url;
-      let response: Response;
-      try {
-        const timeout = AbortSignal.timeout(opts.timeoutMs ?? DISCOVERY_TIMEOUT_MS);
-        response = await opts.fetch(target, { headers, signal: opts.signal ? AbortSignal.any([opts.signal, timeout]) : timeout });
-      } catch (error) {
-        if (opts.signal?.aborted) return { ok: false, reason: "cancelled" };
-        failed = { ok: false, reason: `${url}: ${error instanceof Error && error.name === "TimeoutError" ? "timed out" : error instanceof Error ? error.message : String(error)}` };
-        break;
-      }
-      if (response.status === 401 || response.status === 403) {
-        return { ok: false, status: response.status, reason: `${url}: authentication failed (HTTP ${response.status}); check the API key` };
-      }
-      if (!response.ok) { failed = { ok: false, status: response.status, reason: `${url}: HTTP ${response.status}` }; break; }
-      let json: unknown;
-      try { json = await response.json(); } catch { failed = { ok: false, reason: `${url}: response is not JSON` }; break; }
-      const parsed = parseModelPage(opts.family, json);
-      models.push(...parsed.models);
-      if (!parsed.next) break;
-      query = parsed.next;
-    }
-    if (!failed && models.length > 0) {
-      const seen = new Set<string>();
-      return { ok: true, url, models: models.filter(model => !seen.has(model.id) && seen.add(model.id)) };
-    }
-    last = failed ?? { ok: false, reason: `${url}: the provider returned no models` };
-  }
-  return last;
-}

package/src/runtime/model-replay.ts

@@ -1,10 +0,0 @@
-import { createHash } from "node:crypto";
-import { replayDescriptor } from "../core/model-replay.ts";
-import { hasProviderAccess } from "./provider-access.ts";
-import type { ModelSpec } from "./model.ts";
-
-export function nativeReplay(spec: ModelSpec): boolean { return spec.driver === "pi" || hasProviderAccess(spec); }
-/** The log keeps a digest rather than endpoint values, which can contain private routing information. */
-export function providerReplayKey(spec: ModelSpec): string {
-  return createHash("sha256").update(replayDescriptor({ ...spec, driver: nativeReplay(spec) ? "pi" : "legacy" })).digest("hex");
-}

package/src/runtime/model-scope.ts

@@ -1,20 +0,0 @@
-/** Bun's existing glob implementation supplies matching; ordered scope policy remains pure. */
-import { resolveScope } from "../core/model-scope.ts";
-import { modelKey } from "../core/session-position.ts";
-import { asThinkingLevel } from "../core/thinking.ts";
-import { findModelByPattern } from "./catalog.ts";
-import type { ModelSpec } from "./model.ts";
-
-export function scopedModels(patterns: readonly string[], models: readonly ModelSpec[], strict = false) {
-  return resolveScope(patterns, pattern => {
-    const lower = pattern.toLowerCase();
-    const exact = models.filter(model => modelKey(model).toLowerCase() === lower || model.id.toLowerCase() === lower);
-    if (exact.length === 1) return exact;
-    if (!strict && /[*?\[]/.test(pattern)) {
-      if (asThinkingLevel(pattern.slice(pattern.lastIndexOf(":") + 1))) return [];
-      const glob = new Bun.Glob(lower);
-      return models.filter(model => glob.match(modelKey(model).toLowerCase()) || glob.match(model.id.toLowerCase()));
-    }
-    const found = findModelByPattern(pattern, models); return found.ok ? [found.spec] : [];
-  }, strict);
-}

package/src/runtime/model-sources.ts

@@ -1,151 +0,0 @@
-/** Provider wire metadata is interpreted here, not in the SDK-free core (D13). */
-import { getBuiltinModels, getBuiltinProviders } from "@earendil-works/pi-ai/providers/all";
-import { mergeCatalogs } from "../core/catalog-merge.ts";
-import { THINKING_LEVELS } from "../core/thinking.ts";
-import type { Api, ModelSpec, Price, Effort } from "./model.ts";
-import { isProviderApi, SDK_APIS } from "./provider-protocols.ts";
-
-export interface ProviderDefinition { name: string; env: string[]; api?: Api; baseUrl?: string }
-export interface CatalogExclusion { provider: string; id: string; reason: string }
-export interface SourceCatalog {
-  models: ModelSpec[];
-  providers: Record<string, ProviderDefinition>;
-  excluded: CatalogExclusion[];
-}
-export function record(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-export function finitePositive(value: unknown): value is number { return typeof value === "number" && Number.isFinite(value) && value > 0; }
-export function finiteNonnegative(value: unknown): value is number { return typeof value === "number" && Number.isFinite(value) && value >= 0; }
-
-/** Published unknown prices remain unknown, even when an SDK requires numeric placeholders. */
-function sourcePrice(value: unknown): Price | undefined {
-  if (!record(value) || !finiteNonnegative(value["input"]) || !finiteNonnegative(value["output"])) return undefined;
-  return { input: value["input"], output: value["output"],
-    ...(finiteNonnegative(value["cache_read"]) ? { cacheRead: value["cache_read"] } : {}),
-    ...(finiteNonnegative(value["cache_write"]) ? { cacheWrite: value["cache_write"] } : {}) };
-}
-function priced(spec: ModelSpec, price: Price | undefined): ModelSpec {
-  if (!price) return spec;
-  return { ...spec, price, ...(price.input > 0 && price.cacheRead !== undefined && price.cacheWrite !== undefined
-    ? { cache: spec.api === "anthropic-messages" ? "explicit" as const : "automatic" as const,
-      rates: { read: price.cacheRead / price.input, write: price.cacheWrite / price.input } } : {}) };
-}
-
-export function piSourceCatalog(): SourceCatalog {
-  const out: SourceCatalog = { models: [], providers: {}, excluded: [] };
-  for (const provider of getBuiltinProviders()) {
-    for (const model of getBuiltinModels(provider)) {
-      if (!isProviderApi(model.api)) { out.excluded.push({ provider, id: model.id, reason: `unsupported Pi API ${model.api}` }); continue; }
-      const spec: ModelSpec = { id: model.id, provider, name: model.name, api: model.api, driver: "pi",
-        baseUrl: model.baseUrl.replace(/(?<!\$)\{([A-Z][A-Z_0-9]*)\}/g, "$${$1}"),
-        input: model.input, reasoning: model.reasoning, contextWindow: model.contextWindow, maxTokens: model.maxTokens,
-        ...(model.compat ? { nativeCompat: model.compat as Record<string, unknown> } : {}),
-        ...(model.thinkingLevelMap ? { thinkingLevelMap: model.thinkingLevelMap } : {}),
-        ...(model.samplingParams ? { samplingParams: model.samplingParams } : {}),
-        ...(model.headers ? { defaultHeaders: model.headers } : {}) };
-      // Pi fills missing cost slots with zero. Do not turn those placeholders into measured prices.
-      const cost = model.cost;
-      out.models.push(priced(spec, finiteNonnegative(cost.input) && finiteNonnegative(cost.output) && (cost.input || cost.output) ? { input: cost.input, output: cost.output,
-        ...(finitePositive(cost.cacheRead) ? { cacheRead: cost.cacheRead } : {}), ...(finitePositive(cost.cacheWrite) ? { cacheWrite: cost.cacheWrite } : {}) } : undefined));
-      out.providers[provider] ??= { name: provider, env: [], api: spec.api, ...(spec.baseUrl ? { baseUrl: spec.baseUrl } : {}) };
-    }
-  }
-  return out;
-}
-
-// SDK defaults missing from Models.dev. These are URLs, not protocol guesses.
-// DeepInfra docs/quickstart.mdx; the other defaults are Pi's published provider models.
-const ENDPOINTS: Readonly<Record<string, string>> = {
-  deepinfra: "https://api.deepinfra.com/v1/openai", vercel: "https://ai-gateway.vercel.sh",
-  togetherai: "https://api.together.xyz/v1", azure: "", "azure-cognitive-services": "",
-};
-
-// Dedicated SDK names need not imply dedicated protocols. Only documented compatible endpoints
-// are mapped here (provider-union task card); unknown SDKs remain explicit exclusions.
-const COMPATIBLE_ENDPOINTS: Readonly<Record<string, string>> = {
-  "@ai-sdk/cohere": "https://api.cohere.ai/compatibility/v1",
-  "venice-ai-sdk-provider": "https://api.venice.ai/api/v1",
-  "@aihubmix/ai-sdk-provider": "https://aihubmix.com/v1",
-};
-
-function reasoningMap(value: unknown): ModelSpec["thinkingLevelMap"] {
-  if (!Array.isArray(value)) return undefined;
-  const effort = value.find((entry: unknown) => record(entry) && entry["type"] === "effort");
-  if (!record(effort) || !Array.isArray(effort["values"])) return undefined;
-  const values = effort["values"].filter((x): x is string => typeof x === "string");
-  const map: Partial<Record<Effort, string | null>> = {};
-  for (const level of THINKING_LEVELS) map[level] = values.includes(level) ? level : null;
-  return map;
-}
-
-/** The same normalization feeds the bundled snapshot and explicit refresh. No whitelist of providers. */
-export function modelsDevCatalog(json: unknown, pi: SourceCatalog = piSourceCatalog()): SourceCatalog {
-  const out: SourceCatalog = { models: [], providers: {}, excluded: [] };
-  if (!record(json)) return out;
-  const piModels = new Map(pi.models.map(model => [`${model.provider}/${model.id}`, model]));
-  for (const [rawProvider, value] of Object.entries(json)) {
-    if (!record(value) || !record(value["models"])) continue;
-    // Normalize the upstream spelling to the existing xeno/Pi provider identity before merging.
-    const provider = rawProvider === "togetherai" ? "together" : rawProvider;
-    const piDefault = pi.providers[provider];
-    const env = Array.isArray(value["env"]) ? value["env"].filter((x): x is string => typeof x === "string") : [];
-    const definition: ProviderDefinition = { name: typeof value["name"] === "string" ? value["name"] : provider, env };
-    out.providers[provider] = definition;
-    for (const [key, raw] of Object.entries(value["models"])) {
-      if (!record(raw)) continue;
-      const id = typeof raw["id"] === "string" ? raw["id"] : key;
-      const skip = (reason: string) => { out.excluded.push({ provider, id, reason }); };
-      const modalities = record(raw["modalities"]) ? raw["modalities"] : {};
-      if (raw["tool_call"] === false) { skip("model declares no tool calling"); continue; }
-      if (Array.isArray(modalities["output"]) && !modalities["output"].includes("text")) { skip("non-text output model"); continue; }
-      const modelProvider = record(raw["provider"]) ? raw["provider"] : {};
-      const npm = typeof modelProvider["npm"] === "string" ? modelProvider["npm"] : typeof value["npm"] === "string" ? value["npm"] : "@ai-sdk/openai-compatible";
-      const matched = piModels.get(`${provider}/${id}`);
-      const compatibleEndpoint = COMPATIBLE_ENDPOINTS[npm];
-      const api = matched?.api ?? SDK_APIS[npm] ?? (compatibleEndpoint ? "openai-completions" : undefined);
-      if (!api) { skip(`requires dedicated SDK ${npm}`); continue; }
-      const baseUrl = matched?.baseUrl ?? compatibleEndpoint ?? (typeof modelProvider["api"] === "string" ? modelProvider["api"] : typeof value["api"] === "string" ? value["api"] : ENDPOINTS[rawProvider] ?? piDefault?.baseUrl);
-      if (!baseUrl && !["bedrock-converse-stream", "google-vertex", "azure-openai-responses"].includes(api)) { skip("provider has no verified endpoint; configure baseUrl"); continue; }
-      const limit = record(raw["limit"]) ? raw["limit"] : {};
-      const effort = reasoningMap(raw["reasoning_options"]);
-      const spec: ModelSpec = { ...(matched ?? {}), id, provider, name: typeof raw["name"] === "string" ? raw["name"] : id,
-        api, driver: "pi", reasoning: raw["reasoning"] === true, credentialEnv: env,
-        ...(baseUrl !== undefined ? { baseUrl } : {}),
-        ...(Array.isArray(modalities["input"]) ? { input: modalities["input"].filter((x): x is "text" | "image" => x === "text" || x === "image") } : {}),
-        ...(finitePositive(limit["context"]) ? { contextWindow: limit["context"] } : {}),
-        ...(finitePositive(limit["output"]) ? { maxTokens: limit["output"] } : {}),
-        ...(!matched?.thinkingLevelMap && effort ? { thinkingLevelMap: effort } : {}),
-        ...(!matched && api === "openai-completions" ? { nativeCompat: {
-          supportsStore: false, supportsDeveloperRole: false, maxTokensField: "max_tokens",
-          supportsReasoningEffort: effort !== undefined || provider === "cohere",
-          ...(provider === "cohere" ? { supportsUsageInStreaming: false } : {}),
-        } } : {}),
-        ...(!matched && provider === "cohere" && raw["reasoning"] === true ? {
-          thinkingLevelMap: { off: "none", minimal: "high", low: "high", medium: "high", high: "high", xhigh: "high", max: "high" },
-        } : {}) };
-      // Native Pi compatibility wins over less expressive directory metadata.
-      out.models.push(priced(spec, sourcePrice(raw["cost"])));
-      definition.api ??= api;
-      if (baseUrl) definition.baseUrl ??= baseUrl;
-    }
-  }
-  return out;
-}
-
-export function unionSourceCatalog(json: unknown): SourceCatalog {
-  const pi = piSourceCatalog();
-  const remote = modelsDevCatalog(json, pi);
-  const denied = new Set(remote.excluded.filter(row => row.reason.includes("no tool") || row.reason.includes("non-text")).map(row => `${row.provider}/${row.id}`));
-  const directory = new Map(remote.models.map(model => [`${model.provider}/${model.id}`, model]));
-  const models = mergeCatalogs(remote.models, pi.models.filter(model => !denied.has(`${model.provider}/${model.id}`)))
-    .map(model => {
-      // Pi supplies dialects; the directory supplies public credential names and explicit prices.
-      const metadata = directory.get(`${model.provider}/${model.id}`);
-      return { ...model, ...(metadata?.credentialEnv ? { credentialEnv: metadata.credentialEnv } : {}),
-        ...(metadata?.price ? { price: metadata.price } : {}) };
-    });
-  const included = new Set(models.map(model => `${model.provider}/${model.id}`));
-  return { models, providers: { ...pi.providers, ...remote.providers },
-    excluded: [...pi.excluded, ...remote.excluded].filter(row => !included.has(`${row.provider}/${row.id}`)) };
-}