@visual-z/xeno 0.1.0

package/src/runtime/models-fetch.ts

@@ -0,0 +1,155 @@
+/**
+ * Explicit catalog refresh. The only network read in this area.
+ *
+ * Startup never imports a call to this. `xeno models --refresh` and
+ * `/models refresh` do. A failure (no network, timeout, 404) is a reason
+ * string, not a throw — the caller falls back to the built-in list and
+ * says so. Timeout is 15s, assumed: long enough for a 4.7MB JSON on a
+ * slow link, short enough that a hang is distinguishable from "still
+ * starting".
+ */
+
+import { PROVIDER_WIRE, type Api, type ModelSpec, type Price } from "./model.ts";
+
+export const MODELS_DEV_URL = "https://models.dev/api.json";
+
+/** Assumed. See the file header. */
+const REFRESH_TIMEOUT_MS = 15_000;
+
+export type RefreshResult =
+  | { ok: true; count: number }
+  | { ok: false; reason: string };
+
+export async function refreshRemoteCatalog(opts: {
+  /** Call signature only — `typeof fetch` also has `preconnect`, which a test spy does not. */
+  fetch: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+  write: (value: unknown) => Promise<void>;
+  url?: string;
+}): Promise<RefreshResult> {
+  const url = opts.url ?? MODELS_DEV_URL;
+  let response: Response;
+  try {
+    response = await opts.fetch(url, { signal: AbortSignal.timeout(REFRESH_TIMEOUT_MS) });
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    return { ok: false, reason: `could not refresh models: ${detail}` };
+  }
+  if (!response.ok) {
+    return { ok: false, reason: `could not refresh models: ${url} returned ${response.status}` };
+  }
+  let json: unknown;
+  try {
+    json = await response.json();
+  } catch (err) {
+    return { ok: false, reason: `could not refresh models: body is not JSON (${(err as Error).message})` };
+  }
+  const models = modelsFromRemote(json);
+  if (models.length === 0) {
+    return { ok: false, reason: `could not refresh models: ${url} named no provider we can speak` };
+  }
+  try {
+    await opts.write({ models: models.map(serializeSpec) });
+  } catch (err) {
+    return { ok: false, reason: `could not write models: ${(err as Error).message}` };
+  }
+  return { ok: true, count: models.length };
+}
+
+function modelsFromRemote(json: unknown): ModelSpec[] {
+  if (typeof json !== "object" || json === null) return [];
+  const out: ModelSpec[] = [];
+  for (const [rawId, value] of Object.entries(json as Record<string, unknown>)) {
+    const providerId = rawId === "togetherai" ? "together" : rawId;
+    const wire = PROVIDER_WIRE[rawId] ?? PROVIDER_WIRE[providerId];
+    if (wire === undefined) continue;
+    if (typeof value !== "object" || value === null) continue;
+    const provider = value as Record<string, unknown>;
+    const models = provider["models"];
+    if (typeof models !== "object" || models === null) continue;
+    for (const model of Object.values(models as Record<string, unknown>)) {
+      const spec = specFromRemote(model, providerId, wire);
+      if (spec !== null) out.push(spec);
+    }
+  }
+  return out;
+}
+
+function specFromRemote(
+  raw: unknown,
+  provider: string,
+  wire: { api: Api; baseUrl?: string },
+): ModelSpec | null {
+  if (typeof raw !== "object" || raw === null) return null;
+  const m = raw as Record<string, unknown>;
+  if (m["tool_call"] === false) return null;
+  if (typeof m["id"] !== "string" || m["id"].length === 0) return null;
+  const cost = m["cost"];
+  const limit = m["limit"];
+  const ctx = isRecord(limit) && typeof limit["context"] === "number" ? limit["context"] : undefined;
+  const max = isRecord(limit) && typeof limit["output"] === "number" ? limit["output"] : undefined;
+  const price = priceFromCost(cost);
+  const cache = cacheFromCost(provider, cost);
+  const spec: ModelSpec = {
+    id: m["id"],
+    name: typeof m["name"] === "string" && m["name"].length > 0 ? m["name"] : m["id"],
+    api: wire.api,
+    provider,
+    reasoning: m["reasoning"] === true,
+    ...(wire.baseUrl !== undefined ? { baseUrl: wire.baseUrl } : {}),
+    ...(ctx !== undefined ? { contextWindow: ctx } : {}),
+    ...(max !== undefined ? { maxTokens: max } : {}),
+    ...(price !== undefined ? { price } : {}),
+    ...(cache !== undefined ? cache : {}),
+  };
+  return spec;
+}
+
+function priceFromCost(cost: unknown): Price | undefined {
+  if (!isRecord(cost)) return undefined;
+  const input = cost["input"];
+  const output = cost["output"];
+  if (typeof input !== "number" || typeof output !== "number") return undefined;
+  // Cache dollars are optional. Missing is missing — a 0 here would be
+  // DeepSeek's term, not a default for everyone else.
+  const price: Price = { input, output };
+  if (typeof cost["cache_read"] === "number") price.cacheRead = cost["cache_read"];
+  if (typeof cost["cache_write"] === "number") price.cacheWrite = cost["cache_write"];
+  return price;
+}
+
+function cacheFromCost(
+  provider: string,
+  cost: unknown,
+): { cache: "explicit" | "automatic"; rates: { read: number; write: number } } | undefined {
+  if (!isRecord(cost)) return undefined;
+  const input = cost["input"];
+  const cacheRead = cost["cache_read"];
+  const cacheWrite = cost["cache_write"];
+  if (typeof input !== "number" || input === 0) return undefined;
+  if (typeof cacheRead !== "number" || typeof cacheWrite !== "number") return undefined;
+  return {
+    cache: provider === "anthropic" ? "explicit" : "automatic",
+    rates: { read: cacheRead / input, write: cacheWrite / input },
+  };
+}
+
+function serializeSpec(spec: ModelSpec): Record<string, unknown> {
+  return {
+    id: spec.id,
+    name: spec.name,
+    api: spec.api,
+    provider: spec.provider,
+    reasoning: spec.reasoning,
+    ...(spec.baseUrl !== undefined ? { baseUrl: spec.baseUrl } : {}),
+    ...(spec.cache !== undefined ? { cache: spec.cache } : {}),
+    ...(spec.rates !== undefined ? { rates: spec.rates } : {}),
+    ...(spec.price !== undefined ? { price: spec.price } : {}),
+    ...(spec.contextWindow !== undefined ? { contextWindow: spec.contextWindow } : {}),
+    ...(spec.maxTokens !== undefined ? { maxTokens: spec.maxTokens } : {}),
+    ...(spec.compat !== undefined ? { compat: spec.compat } : {}),
+  };
+}
+
+function isRecord(v: unknown): v is Record<string, unknown> {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}

package/src/runtime/oauth-device.ts

@@ -0,0 +1,86 @@
+/**
+ * RFC 8628 device-code polling.
+ *
+ * Ported from pi (earendil-works/pi, MIT) — packages/ai/src/auth/oauth/device-code.ts
+ *
+ * Isolated from the authorization-code module so Copilot's poll loop does not
+ * drag a callback HTTP server into a path that never binds a port.
+ */
+
+const CANCEL_MESSAGE = "Login cancelled";
+const TIMEOUT_MESSAGE = "Device flow timed out";
+/**
+ * RFC 8628 §3.2: if the authorization server omits `interval`, poll every 5s.
+ * Assumed from the RFC, not measured.
+ */
+const DEFAULT_POLL_INTERVAL_SECONDS = 5;
+const MINIMUM_INTERVAL_MS = 1000;
+/** RFC 8628 §3.5: `slow_down` increases the interval by 5 seconds. */
+const SLOW_DOWN_INTERVAL_INCREMENT_MS = 5000;
+
+type Incomplete =
+  | { status: "pending" }
+  | { status: "slow_down"; intervalSeconds?: number }
+  | { status: "failed"; message: string };
+
+export type DevicePollResult<T> = Incomplete | { status: "complete"; value: T };
+
+export async function abortableSleep(ms: number, signal: AbortSignal): Promise<void> {
+  return new Promise((resolve, reject) => {
+    if (signal.aborted) {
+      reject(new Error(CANCEL_MESSAGE));
+      return;
+    }
+    const onAbort = (): void => {
+      clearTimeout(timeout);
+      reject(new Error(CANCEL_MESSAGE));
+    };
+    const timeout = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+export async function pollDeviceCode<T>(opts: {
+  intervalSeconds?: number;
+  expiresInSeconds?: number;
+  waitBeforeFirstPoll?: boolean;
+  poll: () => Promise<DevicePollResult<T>>;
+  signal: AbortSignal;
+  sleep?: (ms: number, signal: AbortSignal) => Promise<void>;
+}): Promise<T> {
+  const sleep = opts.sleep ?? abortableSleep;
+  const deadline =
+    typeof opts.expiresInSeconds === "number"
+      ? Date.now() + opts.expiresInSeconds * 1000
+      : Number.POSITIVE_INFINITY;
+  let intervalMs = Math.max(
+    MINIMUM_INTERVAL_MS,
+    Math.floor((opts.intervalSeconds ?? DEFAULT_POLL_INTERVAL_SECONDS) * 1000),
+  );
+
+  if (opts.waitBeforeFirstPoll === true) {
+    const remaining = deadline - Date.now();
+    if (remaining > 0) await sleep(Math.min(intervalMs, remaining), opts.signal);
+  }
+
+  while (Date.now() < deadline) {
+    if (opts.signal.aborted) throw new Error(CANCEL_MESSAGE);
+    const result = await opts.poll();
+    if (result.status === "complete") return result.value;
+    if (result.status === "failed") throw new Error(result.message);
+    if (result.status === "slow_down") {
+      const next = result.intervalSeconds;
+      intervalMs =
+        typeof next === "number" && Number.isFinite(next) && next > 0
+          ? Math.max(MINIMUM_INTERVAL_MS, Math.floor(next * 1000))
+          : Math.max(MINIMUM_INTERVAL_MS, intervalMs + SLOW_DOWN_INTERVAL_INCREMENT_MS);
+    }
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) break;
+    await sleep(Math.min(intervalMs, remaining), opts.signal);
+  }
+  throw new Error(TIMEOUT_MESSAGE);
+}