@velum-labs/routekit-registry 0.9.0

package/dist/index.d.ts

@@ -0,0 +1,155 @@
+/**
+ * Typed accessors over RouteKit's generated neutral registry data.
+ *
+ * Provider/auth metadata, model catalogs, capabilities, pricing, and local
+ * model data are generated from spec/registry. Product-specific identities and
+ * panel presets are deliberately excluded.
+ */
+import { REGISTRY } from "./generated/data.js";
+export { REGISTRY };
+export type ProviderAuthStyle = "bearer" | "x-api-key" | "x-goog-api-key";
+export type ProviderKeyProbe = {
+    path: string;
+    auth: ProviderAuthStyle;
+    extraHeaders?: Record<string, string>;
+    invalidStatuses: readonly number[];
+};
+export type ProviderDiscovery = {
+    path: string;
+    auth: ProviderAuthStyle;
+    extraHeaders?: Record<string, string>;
+    responseShape: ProviderDiscoveryResponseShape;
+    pickerDefaultSource?: "live" | "curated";
+};
+export type ProviderDiscoveryResponseShape = "openai" | "anthropic" | "google" | "codex";
+export type ProviderWireProtocol = "openai" | "anthropic" | "google" | "codex";
+export type ProviderWire = {
+    protocol: ProviderWireProtocol;
+    basePath: string;
+};
+export type ProviderInfo = {
+    baseUrl?: string;
+    keyEnv?: string;
+    authTokenEnv?: string;
+    baseUrlEnv?: string;
+    credentialEnvNames?: readonly string[];
+    apiCompatibility?: string;
+    attributionHeaders?: Record<string, string>;
+    keyProbe?: ProviderKeyProbe;
+    discovery?: ProviderDiscovery;
+    wire?: ProviderWire;
+};
+export declare const PROVIDERS: Readonly<Record<string, ProviderInfo>>;
+export declare function providerDefaultBaseUrl(provider: string): string | undefined;
+export declare function defaultKeyEnv(provider: string): string | undefined;
+export declare function providerKeyProbe(provider: string): ProviderKeyProbe | undefined;
+export declare function providerDiscovery(provider: string): ProviderDiscovery | undefined;
+export type SubscriptionMode = "claude-code" | "codex";
+export type SubscriptionOAuthInfo = {
+    tokenEndpoint: string;
+    clientId: string;
+    usageEndpoint: string;
+    profileEndpoint?: string;
+    usagePathFallback?: string;
+};
+export type SubscriptionRateLimitInfo = {
+    headerPrefix: string;
+    activeLimitHeader?: string;
+    retryAfterHeader: string;
+};
+export type SubscriptionAdminInfo = {
+    keyEnv: string;
+    usageEndpoint: string;
+    costEndpoint: string;
+};
+export type SubscriptionInfo = {
+    provider: string;
+    credentialsPath: string;
+    accountsDirectory: string;
+    keychainService?: string;
+    configPath?: string;
+    modelsCachePath?: string;
+    authFileName?: string;
+    defaultModel: string;
+    wire: ProviderWire;
+    discovery: {
+        path: string;
+        responseShape: ProviderDiscoveryResponseShape;
+        clientVersion?: string;
+        cacheFallback?: boolean;
+        extraHeaders?: Record<string, string>;
+    };
+    oauthBetaHeader?: string;
+    spoofSystemPrompt?: string;
+    defaultInstructions?: string;
+    defaultHeaders?: Record<string, string>;
+    requestDefaults?: {
+        stream?: boolean;
+        store?: boolean;
+        omitSampling?: boolean;
+    };
+    oauth: SubscriptionOAuthInfo;
+    rateLimit: SubscriptionRateLimitInfo;
+    admin: SubscriptionAdminInfo;
+    overrideEnv?: Record<string, readonly string[]>;
+};
+export declare const SUBSCRIPTIONS: Readonly<Record<SubscriptionMode, SubscriptionInfo>>;
+export declare function subscriptionInfo(mode: SubscriptionMode): SubscriptionInfo;
+export declare function providerForAuthMode(mode: SubscriptionMode): string;
+export type AccountConnector = "native" | "cliproxy";
+export type AccountConnectorInfo = {
+    connector: AccountConnector;
+    /** CLIProxyAPI login flag (cliproxy-backed kinds only). */
+    cliproxyLoginFlag?: string;
+    /** CLIProxyAPI auth-store `type` values that classify as this kind. */
+    cliproxyAuthTypes?: readonly string[];
+    /** ToS restriction: reverse-engineered upstream, personal/local use only. */
+    localOnly?: boolean;
+    aliases?: readonly string[];
+};
+export declare const ACCOUNT_CONNECTORS: Readonly<Record<string, AccountConnectorInfo>>;
+/** Canonical account kinds known to the neutral registry (not a support contract). */
+export declare function accountKinds(): readonly string[];
+/** Canonical registry kinds plus their aliases (not necessarily public CLI choices). */
+export declare function accountKindChoices(): readonly string[];
+/**
+ * Resolve a user-supplied account kind (canonical name or alias) to its
+ * canonical kind and connector metadata.
+ */
+export declare function resolveAccountConnector(value: string): {
+    kind: string;
+    info: AccountConnectorInfo;
+} | undefined;
+/** Classify a CLIProxyAPI auth-store `type` value back to a canonical kind. */
+export declare function accountKindForCliproxyAuthType(type: string): string | undefined;
+export declare const DEFAULT_REASONING_MODEL: string;
+export declare function catalogDefaultModel(choice: string): string | undefined;
+export declare function curatedModels(choice: string): readonly string[];
+export declare function smokeModelForTool(tool: string): string | undefined;
+export declare function samplingOverridesForModel(model: string): Readonly<Record<string, number>>;
+export declare function chatTemplateKwargsForModel(model: string): Readonly<Record<string, boolean>> | undefined;
+export type RegistryModelPricing = {
+    inputPer1mTokens: number;
+    outputPer1mTokens: number;
+};
+export declare const PRICING_ALIASES: Readonly<Record<string, string>>;
+export declare const DEFAULT_MODEL_PRICING: Readonly<Record<string, RegistryModelPricing>>;
+export type LocalModelRole = "general" | "coder";
+export type LocalCatalogModel = {
+    repo: string;
+    label: string;
+    params: string;
+    quant: string;
+    sizeGB: number;
+    minRamGB: number;
+    blurb: string;
+    role: LocalModelRole;
+};
+export declare const LOCAL_CATALOG_ENTRIES: readonly LocalCatalogModel[];
+export type PreferredLocalModel = {
+    id: string;
+    repo: string;
+};
+export declare const PREFERRED_LOCAL_MODELS: readonly PreferredLocalModel[];
+export declare const GATEWAY_DEFAULT_MLX_MODEL: string;
+export declare const LOCAL_PROBE_MODEL: string;

package/dist/index.js

@@ -0,0 +1,109 @@
+/**
+ * Typed accessors over RouteKit's generated neutral registry data.
+ *
+ * Provider/auth metadata, model catalogs, capabilities, pricing, and local
+ * model data are generated from spec/registry. Product-specific identities and
+ * panel presets are deliberately excluded.
+ */
+import { REGISTRY } from "./generated/data.js";
+export { REGISTRY };
+export const PROVIDERS = REGISTRY.providers;
+export function providerDefaultBaseUrl(provider) {
+    return PROVIDERS[provider]?.baseUrl;
+}
+export function defaultKeyEnv(provider) {
+    return PROVIDERS[provider]?.keyEnv;
+}
+export function providerKeyProbe(provider) {
+    return PROVIDERS[provider]?.keyProbe;
+}
+export function providerDiscovery(provider) {
+    return PROVIDERS[provider]?.discovery;
+}
+export const SUBSCRIPTIONS = REGISTRY.subscriptions;
+export function subscriptionInfo(mode) {
+    return SUBSCRIPTIONS[mode];
+}
+export function providerForAuthMode(mode) {
+    return SUBSCRIPTIONS[mode].provider;
+}
+export const ACCOUNT_CONNECTORS = REGISTRY.connectors;
+/** Canonical account kinds known to the neutral registry (not a support contract). */
+export function accountKinds() {
+    return Object.keys(ACCOUNT_CONNECTORS);
+}
+/** Canonical registry kinds plus their aliases (not necessarily public CLI choices). */
+export function accountKindChoices() {
+    return [
+        ...accountKinds(),
+        ...Object.values(ACCOUNT_CONNECTORS).flatMap((info) => info.aliases ?? [])
+    ];
+}
+/**
+ * Resolve a user-supplied account kind (canonical name or alias) to its
+ * canonical kind and connector metadata.
+ */
+export function resolveAccountConnector(value) {
+    const direct = ACCOUNT_CONNECTORS[value];
+    if (direct !== undefined)
+        return { kind: value, info: direct };
+    for (const [kind, info] of Object.entries(ACCOUNT_CONNECTORS)) {
+        if (info.aliases?.includes(value) === true)
+            return { kind, info };
+    }
+    return undefined;
+}
+/** Classify a CLIProxyAPI auth-store `type` value back to a canonical kind. */
+export function accountKindForCliproxyAuthType(type) {
+    for (const [kind, info] of Object.entries(ACCOUNT_CONNECTORS)) {
+        if (info.cliproxyAuthTypes?.includes(type) === true)
+            return kind;
+    }
+    return undefined;
+}
+export const DEFAULT_REASONING_MODEL = REGISTRY.modelCatalog.defaultReasoningModel;
+export function catalogDefaultModel(choice) {
+    return REGISTRY.modelCatalog.defaultModelByAuthChoice[choice];
+}
+export function curatedModels(choice) {
+    return REGISTRY.modelCatalog.curated[choice] ?? [];
+}
+export function smokeModelForTool(tool) {
+    return REGISTRY.modelCatalog.smokeModels[tool];
+}
+function familyMatches(family, loweredModel) {
+    if (!family.requires.every((needle) => loweredModel.includes(needle)))
+        return false;
+    if (family.anyOf !== undefined && !family.anyOf.some((needle) => loweredModel.includes(needle))) {
+        return false;
+    }
+    return true;
+}
+export function samplingOverridesForModel(model) {
+    const lowered = model.toLowerCase();
+    const families = REGISTRY.modelCapabilities.samplingFamilies;
+    for (const family of families) {
+        if (familyMatches(family, lowered))
+            return family.overrides;
+    }
+    return {};
+}
+export function chatTemplateKwargsForModel(model) {
+    const lowered = model.toLowerCase();
+    const families = REGISTRY.modelCapabilities.chatTemplateFamilies;
+    for (const family of families) {
+        if (familyMatches(family, lowered))
+            return family.chatTemplateKwargs;
+    }
+    return undefined;
+}
+export const PRICING_ALIASES = (REGISTRY.pricing.aliases ?? {});
+export const DEFAULT_MODEL_PRICING = {
+    ...REGISTRY.pricing.models,
+    ...REGISTRY.pricing.manualOverrides
+};
+export const LOCAL_CATALOG_ENTRIES = REGISTRY.localCatalog
+    .entries;
+export const PREFERRED_LOCAL_MODELS = REGISTRY.localCatalog.preferred;
+export const GATEWAY_DEFAULT_MLX_MODEL = REGISTRY.localCatalog.gatewayDefaultModel;
+export const LOCAL_PROBE_MODEL = REGISTRY.localCatalog.probeModel;

package/dist/test/registry.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/registry.test.js

@@ -0,0 +1,75 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { test } from "node:test";
+import { ACCOUNT_CONNECTORS, DEFAULT_MODEL_PRICING, GATEWAY_DEFAULT_MLX_MODEL, LOCAL_CATALOG_ENTRIES, LOCAL_PROBE_MODEL, PREFERRED_LOCAL_MODELS, REGISTRY, accountKindChoices, accountKindForCliproxyAuthType, providerDiscovery, resolveAccountConnector } from "../index.js";
+test("neutral generated registry excludes product and panel data", () => {
+    assert.equal("fusion" in REGISTRY, false);
+    assert.equal("defaultCloudPanel" in REGISTRY.modelCatalog, false);
+    assert.equal("benchmarkPanels" in REGISTRY.modelCatalog, false);
+    const generatedSource = readFileSync(new URL("../../src/generated/data.ts", import.meta.url), "utf8");
+    assert.doesNotMatch(generatedSource, /fusionkit/i);
+});
+test("local catalog defaults reference valid catalog metadata", () => {
+    const repos = new Set(LOCAL_CATALOG_ENTRIES.map((entry) => entry.repo));
+    assert.ok(repos.has(LOCAL_PROBE_MODEL));
+    for (const preferred of PREFERRED_LOCAL_MODELS) {
+        assert.ok(repos.has(preferred.repo), `${preferred.id} must reference a local catalog entry`);
+    }
+    assert.ok(GATEWAY_DEFAULT_MLX_MODEL.length > 0);
+});
+test("neutral pricing and provider metadata remain available", () => {
+    assert.deepEqual(DEFAULT_MODEL_PRICING["gpt-5.5"], {
+        inputPer1mTokens: 1.25,
+        outputPer1mTokens: 10
+    });
+    const discovery = providerDiscovery("openrouter");
+    assert.equal(discovery?.path, "/v1/models");
+    assert.equal(discovery?.pickerDefaultSource, "curated");
+    assert.equal(REGISTRY.providers.openai.wire.protocol, "openai");
+    assert.equal(REGISTRY.providers.anthropic.wire.protocol, "anthropic");
+    assert.equal(REGISTRY.providers.google.wire.protocol, "google");
+    assert.equal(REGISTRY.providers.codex.discovery.responseShape, "codex");
+    assert.equal(REGISTRY.subscriptions["claude-code"].discovery.path, "/v1/models");
+    assert.equal(REGISTRY.subscriptions.codex.discovery.cacheFallback, true);
+    assert.equal(REGISTRY.providers.openrouter.attributionHeaders["X-Title"], "RouteKit");
+    assert.equal(REGISTRY.providers.openrouter.discovery.extraHeaders["X-Title"], "RouteKit");
+    assert.equal(REGISTRY.subscriptions.codex.defaultHeaders.originator, "routekit");
+});
+test("account connector map resolves canonical kinds, aliases, and auth types", () => {
+    // Native subscription kinds stay native; every native kind has full
+    // subscription metadata in the subscriptions section.
+    for (const [kind, info] of Object.entries(ACCOUNT_CONNECTORS)) {
+        if (info.connector === "native") {
+            assert.ok(kind in REGISTRY.subscriptions, `${kind} needs subscription metadata`);
+            assert.equal(info.localOnly, undefined);
+            assert.equal(info.cliproxyLoginFlag, undefined);
+        }
+        else {
+            assert.equal(info.connector, "cliproxy");
+            assert.ok(info.cliproxyLoginFlag?.startsWith("-"), `${kind} needs a login flag`);
+            assert.equal(info.localOnly, true, `${kind} is ToS-restricted to local use`);
+        }
+    }
+    assert.deepEqual(resolveAccountConnector("claude"), {
+        kind: "claude-code",
+        info: ACCOUNT_CONNECTORS["claude-code"]
+    });
+    assert.deepEqual(resolveAccountConnector("antigravity"), {
+        kind: "gemini",
+        info: ACCOUNT_CONNECTORS.gemini
+    });
+    assert.equal(resolveAccountConnector("unknown-kind"), undefined);
+    assert.equal(accountKindForCliproxyAuthType("antigravity"), "gemini");
+    assert.equal(accountKindForCliproxyAuthType("xai"), "grok");
+    assert.equal(accountKindForCliproxyAuthType("vertex"), undefined);
+    assert.deepEqual(accountKindChoices(), [
+        "claude-code",
+        "codex",
+        "gemini",
+        "grok",
+        "kimi",
+        "claude",
+        "antigravity",
+        "xai"
+    ]);
+});

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@velum-labs/routekit-registry",
+  "private": false,
+  "version": "0.9.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/velum-labs/handoffkit.git",
+    "directory": "packages/routekit-registry"
+  },
+  "description": "Product-neutral provider, subscription, model catalog, capability, pricing, and local model registry data.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public",
+    "provenance": true
+  },
+  "keywords": [
+    "routekit",
+    "llm",
+    "registry",
+    "providers",
+    "models"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "tsc -b --clean",
+    "test": "node --test \"dist/test/*.test.js\""
+  }
+}