@agentproto/runtime 1.1.0 → 2.0.0

package/README.md

@@ -45,6 +45,8 @@ A per-boot bearer token is generated automatically and written into `<workspace>
 | Sessions list     | `GET /sessions` / `GET /sessions/:id`    | id-or-name in `:id`                                   |
 | Agent spawn       | `POST /sessions/agent`                   | Long-lived ACP agent (needs `resolveAgentAdapter`)    |
 | Interrupt turn    | `POST /sessions/:id/interrupt`           | Cancel the in-flight turn; session stays alive        |
+| Terminal input    | `POST /sessions/:id/terminal/input`      | Write raw input into a live PTY session               |
+| Rename session    | `PATCH /sessions/:id`                    | Set or clear the session's user-facing `title`/`label`|
 | **PTY spawn**     | **`POST /sessions/terminal`**            | Needs `spawnPty` factory                              |
 | **PTY attach**    | **`WS /sessions/:id/pty`**               | JSON frames `{kind:data|input|resize|exit|ping|pong}`; multi-subscriber, min-size resize, ring-buffer replay |
 | SSE attach        | `GET /sessions/:id/stream`               | Line-by-line text events                              |
@@ -52,7 +54,7 @@ A per-boot bearer token is generated automatically and written into `<workspace>
 
 ### Auth model
 
-- `Authorization: Bearer <token>` required on **mutating** `/sessions/*` routes (POST/DELETE) and the PTY WS upgrade.
+- `Authorization: Bearer <token>` required on **mutating** `/sessions/*` routes (POST/PATCH/DELETE) and the PTY WS upgrade.
 - **No loopback bypass** for those routes — the threat being defended against is a browser fetch from a localhost-loaded page, which IS loopback. A browser can't read `runtime.json` (mode 0600); a same-user process can.
 - Read routes (`GET /sessions`, SSE `/stream`) stay open for read-only telemetry compatibility.
 - The optional `auth?: AuthOptions` field on `createGateway` is for the *tunnel* bearer (Cloudflare-fronted public surface), independent of the per-boot token. It gates `/mcp`, `/events`, `/conversations*`, and the heartbeat tick route, with a loopback bypass for requests that never crossed a tunnel (127.0.0.1/::1 with no `X-Forwarded-For`).

package/dist/catalog-models.d.ts

@@ -0,0 +1,255 @@
+import { AuthProfile } from '@agentproto/auth';
+import { A as AdapterAuthDescriptor } from './spawn-defaults-7uHRnYH1.js';
+import { R as RouteSpec } from './session-config-DIf6wYYP.js';
+import '@agentproto/model-catalog';
+import './context-continuity-B9n0t0v-.js';
+
+/**
+ * Read-only catalog/vendor endpoint (`agentproto-session-config-axes`
+ * SPEC §5) — `GET /catalog/models` + `catalog_models` MCP tool wire into
+ * {@link buildCatalogModels}, the pure join this module owns.
+ *
+ * Reuses three already-shipped pieces instead of rebuilding them:
+ *   - the vendor/product/route model + router widening (OpenRouter/
+ *     Requesty/HuggingFace) from `@agentproto/model-catalog/route-identity`
+ *     (`resolveLlmModelRoute`, `route-identity/index.ts:396-511`) — this is
+ *     what keeps the catalog from being capped at any one adapter's
+ *     `models.allowed` list (SPEC §5.1);
+ *   - the profile eligibility predicate shipped in #470
+ *     (`@agentproto/auth`'s `eligibleProfiles`, `packages/auth/src/
+ *     eligibility.ts:81-89`) for the profile-aware `runnable` flag (SPEC
+ *     §5.3) — the old bare `hasKey` check (`packages/cli/src/commands/
+ *     models.ts:113-117`) is the degenerate one-profile-per-provider case
+ *     this predicate subsumes;
+ *   - `AdapterAuthDescriptor` (`spawn-defaults.ts:226`), the SAME
+ *     provider/authSubscription projection `resolveAuthSpec` reads, as the
+ *     source for which auth methods an adapter can present on its direct
+ *     route (SPEC §3.4's derivable replacement for a hand-maintained
+ *     `authSubscription` boolean).
+ *
+ * A gateway/router route (anything where the resolved route differs from
+ * the model's vendor — `openrouter`, `requesty`, `huggingface`, or an
+ * adapter's own gateway mode id like `moonshot`) always bills against the
+ * route's own id and is always reached with an api-key credential — never
+ * oauth-bearer, since no third-party gateway has an Anthropic-style
+ * subscription bearer path (SPEC §1c: "a moonshot profile, not the Claude
+ * sub"). That structural rule is what lets this module compute
+ * `runnable`/`eligibleProfiles` for the widened, non-curated rows without
+ * per-adapter gateway-vendor tables.
+ */
+
+/** One model entry as declared in an adapter's `models.allowed`
+ *  (`AdapterModelInfo`, `packages/cli/src/registry/resolve.ts:134-142`) —
+ *  the subset this module needs. */
+interface CatalogAdapterModelInput {
+    /** Model id exactly as declared — bare (`"claude-opus-4-8"`) or
+     *  `vendor/product` form. */
+    id: string;
+    /** The billing provider/route this model entry reaches on (`
+     *  AdapterModelInfo.provider`) — e.g. `"moonshot"` or `"openrouter"`.
+     *  Takes precedence over the id's own implied vendor route. */
+    provider?: string;
+    /** The adapter mode id that must be applied to reach this model on a
+     *  non-direct route (`AdapterModelInfo.mode`) — e.g. `"moonshot"`.
+     *  Undefined ⇒ direct route (the model's own vendor, or `provider`). */
+    mode?: string;
+}
+/** One installed adapter's contribution to the catalog. */
+interface CatalogAdapterInput {
+    slug: string;
+    models: readonly CatalogAdapterModelInput[];
+    /** This adapter's billing-auth capability on its DIRECT route — the same
+     *  projection `resolveAuthSpec` reads (`spawn-defaults.ts:226`). Omitted
+     *  ⇒ the adapter presents no auth method, so rows it curates are
+     *  discoverable but never runnable through it alone. */
+    authDescriptor?: AdapterAuthDescriptor;
+    /** How this adapter's spawn ROUTE relates to the chosen model (AIP-45
+     *  launch-menu drill-down). `"free"` = the adapter can route arbitrary
+     *  models through gateways (`base_url`). `"derived-from-model"` = the
+     *  endpoint falls out of the model id's vendor prefix. Absent/undefined
+     *  ⇒ fixed single-provider adapter; widened gateway routes are not
+     *  attached to it. */
+    routeSelection?: "free" | "derived-from-model";
+}
+interface CatalogModelsQuery {
+    /** Keep only routes reachable via this adapter slug. */
+    adapter?: string;
+    /** Keep only this vendor's entry. */
+    vendor?: string;
+    /** Keep only routes with this route id. */
+    route?: string;
+    /** Drop every route with `runnable: false`. */
+    runnableOnly?: boolean;
+}
+interface CatalogPricing {
+    inPer1M: number;
+    outPer1M: number;
+}
+interface CatalogRoute {
+    route: string;
+    ref: string;
+    baseUrl: string | null;
+    pricing: CatalogPricing | null;
+    runnable: boolean;
+    eligibleProfiles: string[];
+    adapterModes: string[];
+    adapters: string[];
+    curated: boolean;
+    /**
+     * True when MORE THAN ONE distinct model is servable on this route across
+     * the whole catalog join (AIP-45 launch-menu drill-down, SPEC §3/§5.3).
+     * Derived from the model×route join, never a hand-maintained table:
+     * `anthropic`/`openrouter`/`llm-endpoint` serve many models (`true`),
+     * a single-model gateway like `moonshot` serves one (`false`). A
+     * single-model route pins every model tier to its one model downstream,
+     * and gates the custom-gateway A-vs-B promotion (SPEC D5). Independent of
+     * the caller's query filters — this is the route's intrinsic capacity, so
+     * the same route reports the same `multiModel` in a filtered response.
+     */
+    multiModel: boolean;
+}
+/**
+ * One route's servable-model index (SPEC §3.9) — the flat, per-route view
+ * that lets a capability-derived UI derive tier pinning without re-walking
+ * the vendor/product tree. `servableModels` is the set of `vendor/product`
+ * model identities reachable on this route across the whole join;
+ * `multiModel` is `servableModels.length > 1` (the same value carried on
+ * every {@link CatalogRoute} with this id). Always the full, unfiltered
+ * catalog capacity, independent of the query — a route's model-count is
+ * intrinsic, not a view of the filtered result.
+ */
+interface CatalogRouteSummary {
+    route: string;
+    servableModels: string[];
+    multiModel: boolean;
+}
+interface CatalogProduct {
+    product: string;
+    routes: CatalogRoute[];
+}
+interface CatalogVendor {
+    vendor: string;
+    products: CatalogProduct[];
+}
+interface CatalogModelsResponse {
+    vendors: CatalogVendor[];
+    /**
+     * Flat servable-models-per-route index (SPEC §3.9), one entry per distinct
+     * route id in the catalog, sorted by route. Exposes the same join the
+     * nested `multiModel` flags derive from, so a capability layer can compute
+     * tier pinning per route without re-walking the vendor tree. Always the
+     * full, unfiltered catalog capacity (see {@link CatalogRouteSummary}).
+     */
+    routes: CatalogRouteSummary[];
+}
+interface BuildCatalogModelsInput {
+    adapters: readonly CatalogAdapterInput[];
+    profiles: readonly AuthProfile[];
+    query?: CatalogModelsQuery;
+}
+/** The pure join (SPEC §5): adapter-declared models + router widening +
+ *  the #470 eligibility predicate → the vendor/product/route tree. No I/O —
+ *  callers (the HTTP route / MCP tool) own loading adapters + profiles. */
+declare function buildCatalogModels(input: BuildCatalogModelsInput): CatalogModelsResponse;
+/**
+ * Resolve the effective billing route for a session: a parseable model ref's
+ * own route is authoritative, `routeGateway` is only consulted when the model
+ * carries no explicit `@route` or is unparseable (including router-prefixed ids
+ * like `openrouter/vendor/product`, which are normalized to the canonical
+ * suffix form first).
+ */
+declare function resolveEffectiveRoute(model: string | undefined, routeGateway: string | undefined): string | undefined;
+/** Rewrite `model`'s `@route` suffix to `route`. Bare/unparseable ids are
+ *  returned unchanged because they have no suffix to rewrite. */
+declare function modelWithRoute(model: string, route: string): string;
+/**
+ * Reconcile independent `model` and `route` overrides so they never describe
+ * two different billing endpoints. Returns the effective values; mutating
+ * callers replace their effective model/route with these results.
+ *
+ * Rules:
+ *  - explicit `@route` on the model wins over a stale/conflicting route.gateway;
+ *  - a route-only override rewrites a parseable model string to match;
+ *  - a model-only override synthesizes a route field whenever the model's
+ *    resolved route differs from the previous route.gateway;
+ *  - passing BOTH overrides that contradict each other is a caller bug → throw.
+ */
+declare function reconcileModelRoute(input: {
+    prevModel?: string;
+    prevRoute?: RouteSpec;
+    model?: string;
+    route?: RouteSpec;
+}): {
+    model?: string;
+    route?: RouteSpec;
+};
+/**
+ * The billing routes that can service `model`, reusing the SAME route-identity
+ * resolution this module's catalog join uses (SPEC §1c serviceability) — never
+ * a parallel per-model provider table. A route R services the model iff:
+ *   - R is the model's catalog billing provider (`getModelProvider` — the native
+ *     vendor SDK for a bare/direct id, or the router for a gateway-only slash id
+ *     like `deepseek/deepseek-v4-pro` ⇒ `openrouter`),
+ *   - R is an explicit `@route` carried in the id (`…@openrouter`), or
+ *   - the model resolves on R as one of the {@link WIDENING_ROUTES} router routes
+ *     (catches requesty-only ids like `sference/…` that carry no pricing-catalog
+ *     `provider` for `getModelProvider` to return).
+ *
+ * Returns the DISTINCT serviceable routes; EMPTY when the model is unknown to
+ * the catalog — a mismatch cannot then be positively proven, so a money-safety
+ * caller MUST NOT reject on an empty result (only on a non-empty set that
+ * excludes the resolved wallet). See {@link checkModelWalletEligibility}.
+ */
+declare function serviceableModelRoutes(model: string): string[];
+/**
+ * Closest known catalog model ids for a slug UNKNOWN to the local catalog —
+ * the "did you mean" set behind the spawn-time model advisory (session-spawn.ts).
+ *
+ * Deliberately narrow to keep false positives near zero: a known id qualifies
+ * ONLY when its {@link bareProduct} equals the input's while the full id
+ * differs — i.e. the caller used the wrong-or-missing vendor/route prefix
+ * (`deepseek-chat` → `deepseek/deepseek-chat`, `glm-5.2` → `z-ai/glm-5.2`,
+ * `moonshot/kimi-k2` → `moonshotai/kimi-k2`). A genuinely-new model on a known
+ * vendor (`qwen/qwen4-max` when only `qwen3-max` is catalogued) shares no bare
+ * product and yields nothing — so a new / free-form slug never earns a spurious
+ * suggestion, matching the money-safety guard's own never-reject-an-unknown-
+ * model rule. Sourced from the catalog itself (`LLM_PRICING_CATALOG` +
+ * `MODEL_ALIASES` keys), never a hand-maintained second list.
+ */
+declare function suggestModelSlugs(model: string): string[];
+/** Verdict of the spawn-time money-safety guard ({@link checkModelWalletEligibility}). */
+interface ModelWalletEligibility {
+    ok: boolean;
+    /** Serviceable routes for the model that DIFFER from the resolved wallet —
+     *  the actionable set to re-spawn onto. Empty when `ok`. */
+    suggestedRoutes: string[];
+}
+/**
+ * Money-safety spawn guard (SPEC §1c): can the resolved billing wallet
+ * `walletRoute` (the gateway id when a `route.gateway` is set, else the resolved
+ * billing provider) service `model`? Reuses {@link serviceableModelRoutes} — no
+ * parallel table. Returns `ok:true` when the model is serviceable on the wallet,
+ * OR when the model is unknown to the catalog (empty serviceable set — a mismatch
+ * cannot be positively proven, so the guard must not reject a possibly-legitimate
+ * new model). Returns `ok:false` with the serviceable alternative routes ONLY
+ * when the model IS serviceable on some route but NOT the resolved wallet — the
+ * exact 404-upstream case (`deepseek/deepseek-v4-pro` on the Anthropic sub). The
+ * guard only REJECTS; it never substitutes a wallet the operator didn't name.
+ */
+declare function checkModelWalletEligibility(model: string, walletRoute: string): ModelWalletEligibility;
+/**
+ * The actionable fail-fast message shared by both spawn paths (session-spawn +
+ * session-restart-core) so they never drift. Names the wallet that couldn't
+ * service the model AND the required route + api-key profile to re-spawn onto —
+ * never a wallet the guard picked for the operator.
+ */
+declare function modelWalletIneligibleMessage(opts: {
+    prefix: string;
+    adapter: string;
+    model: string;
+    walletRoute: string;
+    walletMode?: "subscription" | "api-key";
+    suggestedRoutes: string[];
+}): string;
+
+export { type BuildCatalogModelsInput, type CatalogAdapterInput, type CatalogAdapterModelInput, type CatalogModelsQuery, type CatalogModelsResponse, type CatalogPricing, type CatalogProduct, type CatalogRoute, type CatalogRouteSummary, type CatalogVendor, type ModelWalletEligibility, RouteSpec, buildCatalogModels, checkModelWalletEligibility, modelWalletIneligibleMessage, modelWithRoute, reconcileModelRoute, resolveEffectiveRoute, serviceableModelRoutes, suggestModelSlugs };

package/dist/catalog-models.mjs

@@ -0,0 +1,386 @@
+import { eligibleProfiles } from '@agentproto/auth';
+import { tryParseModelRef, formatModelRef, resolveLlmModelRoute } from '@agentproto/model-catalog/route-identity';
+import { getModelProvider, resolvePricingExact, LLM_PRICING_CATALOG, MODEL_ALIASES } from '@agentproto/model-catalog/llm';
+import { getAnthropicGatewayPreset } from '@agentproto/provider-presets';
+
+/**
+ * @agentproto/runtime v0.1.0-alpha
+ * Long-running gateway: MCP server + HTTP transport + HEARTBEAT autonomy + conversation persistence over a workspace dir.
+ */
+
+var WIDENING_ROUTES = ["openrouter", "requesty", "huggingface"];
+var VENDOR_COMPATIBILITY_ROUTES = {
+  xai: ["xai", "xai-anthropic"]
+};
+function normalizeRouterPrefixedId(id) {
+  const firstSlash = id.indexOf("/");
+  if (firstSlash === -1) return id;
+  const head = id.slice(0, firstSlash);
+  if (!WIDENING_ROUTES.includes(head)) return id;
+  const remainder = id.slice(firstSlash + 1);
+  if (!remainder.includes("/") || remainder.includes("@")) return id;
+  return `${remainder}@${head}`;
+}
+function tryResolveLlmModelRoute(id) {
+  try {
+    return resolveLlmModelRoute(id);
+  } catch {
+    return void 0;
+  }
+}
+function vendorFromIdPrefix(bareId) {
+  if (/^claude[-/]/.test(bareId)) return "anthropic";
+  if (/^(gpt[-/]|o[1-9](-|$)|chatgpt)/.test(bareId)) return "openai";
+  if (/^gemini[-/]/.test(bareId)) return "google";
+  if (/^grok[-/]/.test(bareId)) return "x-ai";
+  if (/^deepseek[-/]/.test(bareId)) return "deepseek";
+  return void 0;
+}
+function resolveModelId(id) {
+  const normalized = normalizeRouterPrefixedId(id);
+  const resolved = tryResolveLlmModelRoute(normalized);
+  if (resolved) {
+    return {
+      vendor: resolved.vendor,
+      product: resolved.product,
+      directRoute: resolved.route,
+      ref: formatModelRef(resolved.ref),
+      baseUrl: resolved.transport.baseUrl ?? null,
+      pricing: {
+        inPer1M: resolved.pricing.inputPer1M,
+        outPer1M: resolved.pricing.outputPer1M
+      }
+    };
+  }
+  const parsed = tryParseModelRef(normalized);
+  if (parsed) {
+    return {
+      vendor: parsed.vendor,
+      product: parsed.product,
+      directRoute: parsed.route,
+      ref: formatModelRef(parsed),
+      baseUrl: null,
+      pricing: null
+    };
+  }
+  const vendor = vendorFromIdPrefix(id) ?? "unknown";
+  return {
+    vendor,
+    product: id,
+    directRoute: vendor,
+    ref: `${vendor}/${id}`,
+    baseUrl: null,
+    pricing: null
+  };
+}
+function methodsForDirect(descriptor) {
+  const methods = [];
+  if (descriptor?.authSubscription) methods.push("oauth-bearer");
+  if (descriptor?.provider || descriptor?.modelDerivedApiKey) methods.push("api-key");
+  return methods;
+}
+function isDirectRoute(route, mode, resolved) {
+  return mode === void 0 && route === resolved.vendor && resolved.directRoute === resolved.vendor;
+}
+function curatedContributions(adapters) {
+  const out = [];
+  for (const adapter of adapters) {
+    for (const model of adapter.models) {
+      const resolved = resolveModelId(model.id);
+      const route = model.mode ?? model.provider ?? resolved.directRoute;
+      const methods = isDirectRoute(route, model.mode, resolved) ? methodsForDirect(adapter.authDescriptor) : ["api-key"];
+      out.push({
+        vendor: resolved.vendor,
+        product: resolved.product,
+        route,
+        ref: resolved.ref,
+        baseUrl: resolved.baseUrl,
+        pricing: resolved.pricing,
+        curated: true,
+        adapterSlug: adapter.slug,
+        ...model.mode ? { adapterMode: model.mode } : {},
+        methods
+      });
+    }
+  }
+  return out;
+}
+function widenedContributions(adapters, curated) {
+  const freeAdapters = adapters.filter((a) => a.routeSelection === "free").map((a) => a.slug);
+  if (freeAdapters.length === 0) return [];
+  const seenProducts = /* @__PURE__ */ new Map();
+  for (const c of curated) {
+    const key = `${c.vendor}/${c.product}`;
+    const routes = seenProducts.get(key) ?? /* @__PURE__ */ new Set();
+    routes.add(c.route);
+    seenProducts.set(key, routes);
+  }
+  const out = [];
+  for (const [key, existingRoutes] of seenProducts) {
+    const [vendor, product] = key.split("/", 2);
+    for (const router of WIDENING_ROUTES) {
+      if (existingRoutes.has(router)) continue;
+      const resolved = resolveLlmModelRoute(`${vendor}/${product}@${router}`);
+      if (!resolved) continue;
+      for (const adapterSlug of freeAdapters) {
+        out.push({
+          vendor,
+          product,
+          route: router,
+          ref: formatModelRef(resolved.ref),
+          baseUrl: resolved.transport.baseUrl ?? null,
+          pricing: {
+            inPer1M: resolved.pricing.inputPer1M,
+            outPer1M: resolved.pricing.outputPer1M
+          },
+          curated: false,
+          adapterSlug,
+          methods: ["api-key"]
+        });
+      }
+    }
+  }
+  return out;
+}
+function compatibilityContributions(adapters) {
+  const freeAdapters = adapters.filter((a) => a.routeSelection === "free").map((a) => a.slug);
+  const out = [];
+  for (const [product, pricing] of Object.entries(LLM_PRICING_CATALOG)) {
+    if (pricing.provider !== "xai") continue;
+    const vendor = pricing.vendor ?? "xai";
+    const compatRoutes = VENDOR_COMPATIBILITY_ROUTES[vendor];
+    if (!compatRoutes) continue;
+    const direct = resolveLlmModelRoute(`${vendor}/${product}`);
+    if (!direct) continue;
+    for (const route of compatRoutes) {
+      const ref = route === vendor ? `${vendor}/${product}` : `${vendor}/${product}@${route}`;
+      const baseUrl = route === "xai-anthropic" ? getAnthropicGatewayPreset("xai-anthropic").baseUrl : null;
+      const rowBase = {
+        vendor,
+        product,
+        route,
+        ref,
+        baseUrl,
+        pricing: {
+          inPer1M: direct.pricing.inputPer1M,
+          outPer1M: direct.pricing.outputPer1M
+        },
+        curated: false,
+        methods: ["api-key"]
+      };
+      if (route === "xai-anthropic" && freeAdapters.length > 0) {
+        for (const adapterSlug of freeAdapters) {
+          out.push({ ...rowBase, adapterSlug });
+        }
+      } else {
+        out.push(rowBase);
+      }
+    }
+  }
+  return out;
+}
+function mergeContributions(contributions) {
+  const rows = /* @__PURE__ */ new Map();
+  for (const c of contributions) {
+    const key = `${c.vendor}\0${c.product}\0${c.route}`;
+    const existing = rows.get(key);
+    if (!existing) {
+      rows.set(key, {
+        vendor: c.vendor,
+        product: c.product,
+        route: c.route,
+        ref: c.ref,
+        baseUrl: c.baseUrl,
+        pricing: c.pricing,
+        curated: c.curated,
+        adapters: c.adapterSlug ? [c.adapterSlug] : [],
+        adapterModes: c.adapterMode ? [c.adapterMode] : [],
+        methods: [...c.methods]
+      });
+      continue;
+    }
+    existing.curated = existing.curated || c.curated;
+    existing.baseUrl = existing.baseUrl ?? c.baseUrl;
+    existing.pricing = existing.pricing ?? c.pricing;
+    if (c.adapterSlug && !existing.adapters.includes(c.adapterSlug)) {
+      existing.adapters.push(c.adapterSlug);
+    }
+    if (c.adapterMode && !existing.adapterModes.includes(c.adapterMode)) {
+      existing.adapterModes.push(c.adapterMode);
+    }
+    for (const m of c.methods) {
+      if (!existing.methods.includes(m)) existing.methods.push(m);
+    }
+  }
+  return [...rows.values()];
+}
+function billedVendor(vendor, route) {
+  return route === vendor ? vendor : route;
+}
+function profileAllowsModel(profile, ref, vendorProduct) {
+  const curation = profile.models;
+  if (!curation || curation.mode === "all") return true;
+  const slash = vendorProduct.indexOf("/");
+  const product = slash === -1 ? vendorProduct : vendorProduct.slice(slash + 1);
+  const isDirect = !ref.includes("@");
+  return curation.ids.includes(ref) || curation.ids.includes(vendorProduct) || isDirect && curation.ids.includes(product);
+}
+function buildCatalogModels(input) {
+  const curated = curatedContributions(input.adapters);
+  const contributions = [
+    ...curated,
+    ...widenedContributions(input.adapters, curated),
+    ...compatibilityContributions(input.adapters)
+  ];
+  const merged = mergeContributions(contributions);
+  const query = input.query ?? {};
+  const servableByRoute = /* @__PURE__ */ new Map();
+  for (const row of merged) {
+    const set = servableByRoute.get(row.route) ?? /* @__PURE__ */ new Set();
+    set.add(`${row.vendor}/${row.product}`);
+    servableByRoute.set(row.route, set);
+  }
+  const isMultiModel = (route) => (servableByRoute.get(route)?.size ?? 0) > 1;
+  const vendors = /* @__PURE__ */ new Map();
+  for (const row of merged) {
+    if (query.vendor && row.vendor !== query.vendor) continue;
+    if (query.route && row.route !== query.route) continue;
+    if (query.adapter && !row.adapters.includes(query.adapter)) continue;
+    const isDirectVendorRoute = row.route === row.vendor && row.adapterModes.length === 0;
+    const walletEligible = !isDirectVendorRoute || checkModelWalletEligibility(`${row.vendor}/${row.product}`, row.route).ok;
+    const manifest = {
+      id: `${row.vendor}/${row.product}@${row.route}`,
+      endpointByRoute: { [row.route]: billedVendor(row.vendor, row.route) },
+      methodsByRoute: { [row.route]: row.methods }
+    };
+    const eligible = walletEligible ? eligibleProfiles(input.profiles, manifest, row.route).filter(
+      (p) => profileAllowsModel(p, row.ref, `${row.vendor}/${row.product}`)
+    ) : [];
+    const runnable = eligible.length > 0;
+    if (query.runnableOnly && !runnable) continue;
+    const route = {
+      route: row.route,
+      ref: row.ref,
+      baseUrl: row.baseUrl,
+      pricing: row.pricing,
+      runnable,
+      eligibleProfiles: eligible.map((p) => p.id),
+      adapterModes: row.adapterModes,
+      adapters: row.adapters,
+      curated: row.curated,
+      multiModel: isMultiModel(row.route)
+    };
+    const products = vendors.get(row.vendor) ?? /* @__PURE__ */ new Map();
+    vendors.set(row.vendor, products);
+    const routes2 = products.get(row.product) ?? [];
+    products.set(row.product, routes2);
+    routes2.push(route);
+  }
+  const result = [...vendors.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([vendor, products]) => ({
+    vendor,
+    products: [...products.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([product, routes2]) => ({
+      product,
+      routes: [...routes2].sort((a, b) => a.route.localeCompare(b.route))
+    }))
+  }));
+  const routes = [...servableByRoute.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([route, models]) => ({
+    route,
+    servableModels: [...models].sort((a, b) => a.localeCompare(b)),
+    multiModel: models.size > 1
+  }));
+  return { vendors: result, routes };
+}
+function resolveEffectiveRoute(model, routeGateway) {
+  if (!model) return routeGateway;
+  const normalized = normalizeRouterPrefixedId(model);
+  const parsed = tryParseModelRef(normalized);
+  if (!parsed) return routeGateway;
+  if (parsed.route !== parsed.vendor) return parsed.route;
+  return routeGateway ?? parsed.route;
+}
+function modelWithRoute(model, route) {
+  const parsed = tryParseModelRef(model);
+  if (!parsed) return model;
+  return formatModelRef({ ...parsed, route });
+}
+function reconcileModelRoute(input) {
+  const { prevModel, prevRoute, model: overrideModel, route: overrideRoute } = input;
+  if (overrideModel !== void 0 && overrideRoute !== void 0) {
+    const parsed = tryParseModelRef(overrideModel);
+    if (parsed && parsed.route !== parsed.vendor && parsed.route !== overrideRoute.gateway) {
+      throw new Error(
+        `reconcileModelRoute: model "${overrideModel}" pins route "${parsed.route}" but route override is "${overrideRoute.gateway}"`
+      );
+    }
+    return { model: overrideModel, route: overrideRoute };
+  }
+  if (overrideModel !== void 0) {
+    const parsed = tryParseModelRef(overrideModel);
+    if (parsed) {
+      const hasExplicitRoute = parsed.route !== parsed.vendor;
+      if (hasExplicitRoute && prevRoute?.gateway !== parsed.route) {
+        return { model: overrideModel, route: { gateway: parsed.route } };
+      }
+      if (!hasExplicitRoute && prevRoute && prevRoute.gateway !== parsed.route) {
+        return { model: overrideModel, route: { gateway: parsed.route } };
+      }
+    }
+    return { model: overrideModel, route: prevRoute };
+  }
+  if (overrideRoute !== void 0) {
+    if (prevModel !== void 0) {
+      return { model: modelWithRoute(prevModel, overrideRoute.gateway), route: overrideRoute };
+    }
+    return { route: overrideRoute };
+  }
+  return { model: prevModel, route: prevRoute };
+}
+function serviceableModelRoutes(model) {
+  const routes = /* @__PURE__ */ new Set();
+  const provider = getModelProvider(model);
+  if (provider) routes.add(provider);
+  const parsed = tryParseModelRef(normalizeRouterPrefixedId(model));
+  if (parsed) {
+    if (parsed.route !== parsed.vendor) routes.add(parsed.route);
+    if (resolvePricingExact(parsed.product)?.provider === parsed.vendor) {
+      routes.add(parsed.vendor);
+    }
+    for (const router of WIDENING_ROUTES) {
+      if (tryResolveLlmModelRoute(`${parsed.vendor}/${parsed.product}@${router}`)) {
+        routes.add(router);
+      }
+    }
+  }
+  return [...routes];
+}
+function bareProduct(id) {
+  const noSuffix = id.split("@")[0].split(":")[0];
+  const slash = noSuffix.lastIndexOf("/");
+  return (slash === -1 ? noSuffix : noSuffix.slice(slash + 1)).toLowerCase();
+}
+function suggestModelSlugs(model) {
+  const target = bareProduct(model);
+  if (!target) return [];
+  const out = /* @__PURE__ */ new Set();
+  for (const id of [...Object.keys(LLM_PRICING_CATALOG), ...Object.keys(MODEL_ALIASES)]) {
+    if (id !== model && bareProduct(id) === target) out.add(id);
+  }
+  return [...out].sort().slice(0, 5);
+}
+function checkModelWalletEligibility(model, walletRoute) {
+  const serviceable = serviceableModelRoutes(model);
+  if (serviceable.length === 0 || serviceable.includes(walletRoute)) {
+    return { ok: true, suggestedRoutes: [] };
+  }
+  return { ok: false, suggestedRoutes: serviceable.filter((r) => r !== walletRoute) };
+}
+function modelWalletIneligibleMessage(opts) {
+  const wallet = opts.walletMode ? `"${opts.walletRoute}" ${opts.walletMode} wallet` : `"${opts.walletRoute}" wallet`;
+  const primary = opts.suggestedRoutes[0] ?? "a gateway route";
+  const also = opts.suggestedRoutes.length > 1 ? ` (also serviceable via ${opts.suggestedRoutes.slice(1).map((r) => `"${r}"`).join(", ")})` : "";
+  return `${opts.prefix}: model "${opts.model}" is not serviceable on the resolved ${wallet} (adapter "${opts.adapter}") and would 404 upstream. This model bills route "${primary}"${also} \u2014 re-spawn on it: set route.gateway="${primary}" with an eligible "${primary}" api-key profile (access.profileRef). This guard only rejects; it never switches wallets for you.`;
+}
+
+export { buildCatalogModels, checkModelWalletEligibility, modelWalletIneligibleMessage, modelWithRoute, reconcileModelRoute, resolveEffectiveRoute, serviceableModelRoutes, suggestModelSlugs };
+//# sourceMappingURL=catalog-models.mjs.map
+//# sourceMappingURL=catalog-models.mjs.map