@molecule/api-resource-ai-models 1.0.0

package/dist/requestHandlerMap.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Maps route handler names to their implementations.
+ *
+ * @module
+ */
+import { list } from './handlers/list.js';
+/**
+ * Map of request handlers for the AI model catalog routes.
+ */
+export declare const requestHandlerMap: {
+    readonly list: typeof list;
+};
+//# sourceMappingURL=requestHandlerMap.d.ts.map

package/dist/requestHandlerMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"requestHandlerMap.d.ts","sourceRoot":"","sources":["../src/requestHandlerMap.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAA;AAEzC;;GAEG;AACH,eAAO,MAAM,iBAAiB;;CAEpB,CAAA"}

package/dist/requestHandlerMap.js

@@ -0,0 +1,12 @@
+/**
+ * Maps route handler names to their implementations.
+ *
+ * @module
+ */
+import { list } from './handlers/list.js';
+/**
+ * Map of request handlers for the AI model catalog routes.
+ */
+export const requestHandlerMap = {
+    list,
+};

package/dist/routes.d.ts

@@ -0,0 +1,13 @@
+/**
+ * AI model catalog routes.
+ *
+ * @module
+ */
+/** Route array for the AI model catalog: GET list of available models. */
+export declare const routes: readonly [{
+    readonly method: "get";
+    readonly path: "/ai/models";
+    readonly handler: "list";
+    readonly middlewares: readonly ["authenticate"];
+}];
+//# sourceMappingURL=routes.d.ts.map

package/dist/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../src/routes.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,0EAA0E;AAC1E,eAAO,MAAM,MAAM;;;;;EAOT,CAAA"}

package/dist/routes.js

@@ -0,0 +1,14 @@
+/**
+ * AI model catalog routes.
+ *
+ * @module
+ */
+/** Route array for the AI model catalog: GET list of available models. */
+export const routes = [
+    {
+        method: 'get',
+        path: '/ai/models',
+        handler: 'list',
+        middlewares: ['authenticate'],
+    },
+];

package/dist/types.d.ts

@@ -0,0 +1,315 @@
+/**
+ * AI model catalog types.
+ *
+ * Single source of truth for model metadata. The full `ModelDefinition` is
+ * consumed both by server-side code (chat handler, compaction) and over the
+ * wire by `GET /ai/models`. Nothing in this shape is sensitive enough to hide
+ * from authenticated clients today; if that changes, introduce a `PublicModel`
+ * projection here and have the handler convert before responding.
+ *
+ * @module
+ */
+/**
+ * AI provider identifier.
+ *
+ * Maps to the bond category used at runtime (e.g. `bond('ai', 'anthropic', anthropicProvider)`).
+ * Adding a new provider here means a corresponding AI bond package must exist.
+ */
+export type AIProviderID = 'anthropic' | 'openai' | 'google' | 'xai' | 'deepseek' | 'meta' | 'moonshot' | 'minimax' | 'alibaba' | 'zhipu'
+/**
+ * A model served by a USER-configured endpoint + key (bring-your-own AI)
+ * rather than a platform bond. Never appears in the static catalog — hosts
+ * synthesize these definitions at runtime from per-project provider config,
+ * with all prices 0 (the user pays their own provider directly).
+ */
+ | 'custom';
+/**
+ * A reasoning-effort value — a model's OWN native effort level.
+ *
+ * There is no abstract cross-model scale: the value stored on a project and
+ * sent to the provider IS the model's real level (e.g. `'high'` / `'xhigh'` /
+ * `'max'` on current Claude models, `'medium'` on Grok, or a scaled
+ * thinking-budget label like `'16K'` on budget-configurable models). Each model
+ * declares its own ordered {@link ModelDefinition.supportedEffortLevels}; a
+ * value that isn't in the active model's set degrades to the nearest one (see
+ * `model-selection.ts`). Mirrored by the client-side `EffortLevel` in
+ * `@molecule/app-ai-models`; keep the two in sync. Re-declared (rather than
+ * imported) by the ide-react and molecule-dev consumers per the cross-stack
+ * rule, but this catalog is the canonical home.
+ */
+export type EffortLevel = string;
+/**
+ * Full server-side metadata for an AI model. Consumed directly by the chat
+ * handler, compaction, and any other server-side cost / budget logic.
+ */
+export interface ModelDefinition {
+    /** API model ID (e.g. `'claude-sonnet-4-6'`, `'gpt-5.4'`). */
+    id: string;
+    /** Which AI provider serves this model. */
+    provider: AIProviderID;
+    /** Human-readable label (e.g. `'Claude Sonnet 4.6'`). */
+    label: string;
+    /** Short description for UI display. */
+    description: string;
+    /** Maximum input context window in tokens. */
+    contextWindow: number;
+    /** Maximum output tokens per response. */
+    maxOutputTokens: number;
+    /** Whether the model supports extended thinking / chain-of-thought. */
+    supportsThinking: boolean;
+    /** Default thinking budget in tokens (only relevant when `supportsThinking` is true). */
+    thinkingBudgetTokens: number;
+    /**
+     * Whether the thinking budget can be controlled via API params.
+     * When false, the model always reasons but does not accept a thinking / reasoning_effort param.
+     */
+    thinkingConfigurable: boolean;
+    /**
+     * The model's OWN reasoning-effort levels, ordered ascending (least → most
+     * effort) — the exact values a user picks, that get persisted, and that the
+     * `/effort` command offers. There is NO abstract scale: these are the model's
+     * real levels.
+     *
+     * - **Native-effort models** (Anthropic `output_config.effort`, OpenAI
+     *   `reasoning_effort`, Gemini `thinking_level`, …) list their provider values
+     *   verbatim, e.g. `['low', 'high', 'xhigh', 'max']` — each value is sent as
+     *   the provider's effort param as-is.
+     * - **Budget-configurable models** (a raw thinking-token budget, no native
+     *   level names — e.g. Claude Haiku 4.5, Qwen3.7) list scaled-budget LABELS,
+     *   e.g. `['4K', '8K', '16K', '32K']`, with {@link effortBudgetTokens} mapping
+     *   each label to the actual token budget sent.
+     * - **Fixed-reasoning models** (DeepSeek executors, Kimi, …) omit this field
+     *   entirely — reasoning depth can't be tuned, so there is nothing to pick.
+     *
+     * A persisted value outside the active model's set degrades to the nearest one
+     * (`model-selection.ts` `resolveEffortForModel`). Absent → no effort choice.
+     */
+    supportedEffortLevels?: EffortLevel[];
+    /**
+     * The model's default effort value — the one used when the user hasn't chosen.
+     * MUST be a member of {@link supportedEffortLevels}. Absent only when the model
+     * has no effort levels (fixed reasoning).
+     */
+    defaultEffortLevel?: EffortLevel;
+    /**
+     * For budget-configurable models ONLY: maps each label in
+     * {@link supportedEffortLevels} to the thinking-token budget it sends
+     * (e.g. `{ '4K': 4000, '8K': 8000, '16K': 16000, '32K': 32000 }`). Its
+     * presence is what marks a model as budget-driven rather than native-effort:
+     * a model WITH this map sends `budget_tokens`; a model WITHOUT it sends its
+     * chosen level as the provider's native effort param.
+     *
+     * CRITICAL for Anthropic 4.6+ models (Fable 5, Opus 4.8/4.6, Sonnet 5 / 4.6):
+     * these must NOT carry this map — they are native-effort models, and sending
+     * `budget_tokens` returns a 400 on Fable 5 / Opus 4.8 / Sonnet 5.
+     */
+    effortBudgetTokens?: Record<string, number>;
+    /** Whether the model supports vision (images, documents, etc.). */
+    supportsVision: boolean;
+    /** Whether the model supports prompt caching. */
+    supportsPromptCaching: boolean;
+    /** Whether the model supports tool use / function calling. */
+    supportsTools: boolean;
+    /**
+     * The model cannot combine function tools with ANY reasoning on the provider's
+     * chat-completions endpoint, so a request carrying tools must pin reasoning
+     * OFF or it is rejected outright.
+     *
+     * Set for the gpt-5.6 family, which answers a tools request with:
+     * `Function tools with reasoning_effort are not supported for <model> in
+     * /v1/chat/completions. To use function tools, use /v1/responses or set
+     * reasoning_effort to 'none'.` (400 — verified live, 2026-07-30). Omitting the
+     * effort field entirely does NOT help: the model applies its own default and
+     * still 400s. Only an explicit `'none'` works.
+     *
+     * This is a per-model API fact, so it lives in the catalogue rather than as a
+     * model-name branch inside a bond.
+     *
+     * **This is a workaround, not the fix.** Pinning reasoning off means an agentic
+     * caller — which always carries tools — never gets reasoning from these models.
+     * The real fix is migrating the OpenAI bond to `/v1/responses`, which supports
+     * both together; until then, working-without-reasoning beats 400.
+     */
+    toolsRequireReasoningOff?: boolean;
+    /**
+     * Provider-specific server tool type for web search (e.g. `'web_search_20250305'`).
+     * When set, the chat handler sends this as a ServerTool alongside custom tools.
+     * Omit if the model / provider does not support native web search.
+     */
+    webSearchToolType?: string;
+    /**
+     * Provider-specific server tool type for code execution (e.g. `'code_execution_20250825'`).
+     * Omit if the model / provider does not support native code execution.
+     */
+    codeExecutionToolType?: string;
+    /**
+     * Provider-specific server tool type for web fetch / URL context (e.g. `'web_fetch_20260209'`).
+     * Omit if the model / provider does not support native web fetch.
+     */
+    webFetchToolType?: string;
+    /** Whether this model is available on the free tier (only one model should be true). */
+    freeTier?: boolean;
+    /**
+     * Regions in which this model is free-tier selectable even though the model
+     * as a whole is not `freeTier` — for models whose regional hosts price very
+     * differently (e.g. a cheap native host powering the free planner while its
+     * ~3× re-host stays paid-only). Ignored when `freeTier` is true (all regions
+     * free); omitted → no free-tier access outside `freeTier`.
+     */
+    freeTierRegions?: string[];
+    /**
+     * Processing regions this model can run in, as arbitrary region codes; the
+     * FIRST entry is the model's default region. Omit for `['us']` (the platform
+     * default — a single-region US model). A single-entry list pins the model to
+     * that region regardless of the user's per-model choice (e.g. `['cn']` for a
+     * model with no US re-host). Dispatch resolves a region to the
+     * `<provider>-<region>` named bond (`'us'` → the bare `<provider>` bond).
+     */
+    regions?: string[];
+    /**
+     * Per-region price overrides in USD per MTok, keyed by region code, for
+     * regions whose host bills differently from the base rates (e.g. a US
+     * re-host of a Chinese-origin model). The BASE `*PricePerMTok` fields always
+     * carry the native provider's list prices (what models.dev / the freshness
+     * gate verify); a region with no entry here bills at the base rates. Omitted
+     * cache fields fall back to the region's `inputPricePerMTok` (hosts with no
+     * cache discount / no write premium).
+     */
+    regionPricing?: Record<string, {
+        /** Region input price per million uncached tokens in USD. */
+        inputPricePerMTok: number;
+        /** Region output price per million tokens in USD. */
+        outputPricePerMTok: number;
+        /** Region prompt-cache read price per million tokens in USD. */
+        cacheReadPricePerMTok?: number;
+        /** Region prompt-cache write price per million tokens in USD. */
+        cacheWritePricePerMTok?: number;
+    }>;
+    /** Input price per million *uncached* (fresh) input tokens in USD. */
+    inputPricePerMTok: number;
+    /** Output price per million tokens in USD. */
+    outputPricePerMTok: number;
+    /**
+     * Price per million prompt-cache *read* (cache-hit) input tokens in USD.
+     *
+     * REQUIRED — never omit. Prompt caching is enabled for the agentic loop, so
+     * for a long conversation the cache-read tokens are the DOMINANT input
+     * category. Pricing them at `0` (the bug this field fixes) systematically
+     * under-measures real upstream spend and lets cost-gated budgets be blown
+     * past their caps. Conventionally a steep discount on `inputPricePerMTok`
+     * (e.g. Anthropic / OpenAI / DeepSeek bill cache reads at ~0.1×). MUST be
+     * `<= inputPricePerMTok` — a cache hit is never more expensive than fresh
+     * input.
+     */
+    cacheReadPricePerMTok: number;
+    /**
+     * Price per million prompt-cache *write* (cache-creation) input tokens in USD.
+     *
+     * REQUIRED — never omit. The first time a prefix is cached the provider may
+     * charge a premium (Anthropic's 5-minute cache write is ~1.25× input);
+     * providers that auto-cache at no extra charge (OpenAI, DeepSeek) set this
+     * equal to `inputPricePerMTok`. MUST be `>= inputPricePerMTok` — a cache
+     * write is never cheaper than fresh input. Only the Anthropic bond currently
+     * emits `cacheCreationInputTokens`, but every model declares this so a new
+     * cache-emitting bond can never silently bill cache writes at `0`.
+     */
+    cacheWritePricePerMTok: number;
+    /**
+     * Optional provider peak-hour pricing: during the listed UTC windows, ALL of
+     * this model's token prices (input, output, cache read/write) bill at
+     * `multiplier × ` the listed rates. Metering MUST price each request by its
+     * own timestamp via `priceMultiplierAt()` — never assume the flat rate — or
+     * peak-hour usage is under-metered and the platform eats the difference
+     * (e.g. DeepSeek's announced 2× Beijing-business-hours pricing).
+     *
+     * Windows are minutes-since-midnight UTC, half-open `[start, end)`; a window
+     * may wrap midnight (`start > end`).
+     */
+    peakPricing?: {
+        windows: {
+            startMinuteUtc: number;
+            endMinuteUtc: number;
+        }[];
+        multiplier: number;
+    };
+    /**
+     * Fast-mode ("priority speed") pricing — the per-MTok rates billed when a
+     * request runs with the provider's fast/priority tier (e.g. Anthropic's
+     * `speed: "fast"` research preview: same model, up to ~2.5× output speed, at
+     * premium pricing). PRESENCE of this field is the capability flag: a model
+     * without it does not support fast mode, and metering/UI/dispatch all key off
+     * that. All four fields are required for the same never-under-meter reasons
+     * as the base rates. Metering MUST price a turn by the speed the provider
+     * REPORTS it ran at (`TokenUsage.speed`), not the speed requested — a
+     * fast-mode 429 that falls back to standard must not bill 2×.
+     */
+    fastPricing?: {
+        /** Fast-mode input price per million uncached tokens in USD. */
+        inputPricePerMTok: number;
+        /** Fast-mode output price per million tokens in USD. */
+        outputPricePerMTok: number;
+        /** Fast-mode prompt-cache read price per million tokens in USD. */
+        cacheReadPricePerMTok: number;
+        /** Fast-mode prompt-cache write price per million tokens in USD. */
+        cacheWritePricePerMTok: number;
+    };
+    /** Reliable knowledge cutoff date (YYYY-MM-DD). */
+    knowledgeCutoff: string;
+    /**
+     * When the model was (or will be) deprecated (YYYY-MM-DD).
+     *
+     * Past dates: still selectable, but the picker tucks them into an "Older
+     * models" section so newcomers default to current entries. Saved selections
+     * (a user previously picked this) keep working. Future dates: still treated
+     * as current — useful for scheduling a deprecation in advance.
+     *
+     * Omit entirely for current models.
+     */
+    deprecatedAt?: string;
+    /**
+     * Whether this model is fully disabled — removed from selection and the
+     * public listing while remaining priceable for historical usage.
+     *
+     * Stronger than {@link deprecatedAt}: a deprecated model is still selectable
+     * (the picker just tucks it into an "Older models" section), whereas a
+     * disabled model vanishes from every *exposure* surface — it is excluded from
+     * `MODEL_IDS`, `getAvailableModels()`, the `GET /ai/models` listing, and the
+     * client-side free-tier / deprecation-partition helpers. Use it for a model
+     * the provider has retired or deprecated (e.g. `grok-code-fast-1`).
+     *
+     * `getModel(id)` STILL returns a disabled entry so a saved selection or a
+     * historical usage row can always be priced — NEVER delete a disabled model,
+     * or its past usage silently meters as free. Omit entirely for active models.
+     */
+    disabled?: boolean;
+}
+/**
+ * The model ids the SERVER falls back to per mode/job when the user hasn't
+ * picked one — already resolved for the requester's tier (a free-tier caller
+ * sees the free-tier clamp ids, a paid caller the paid defaults). Lets the
+ * client label an unset per-mode picker "Default (<model>)" instead of a
+ * vague "default" the user can't decode.
+ */
+export interface ModeModelDefaults {
+    /** Model id used in plan mode when nothing is configured. */
+    plan: string;
+    /** Model id used in execute mode when nothing is configured. */
+    execute: string;
+    /** Model id used for commit-message generation when nothing is configured. */
+    commit: string;
+    /** Model id used for conversation compaction when nothing is configured. */
+    compact: string;
+}
+/**
+ * Response shape returned by `GET /ai/models`.
+ */
+export interface ListModelsResponse {
+    models: ModelDefinition[];
+    /**
+     * Per-mode server default model ids for the requester's tier. Optional —
+     * servers that don't compute tier-aware defaults omit it, and clients fall
+     * back to generic "default" labeling.
+     */
+    defaults?: ModeModelDefaults;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

@@ -0,0 +1,12 @@
+/**
+ * AI model catalog types.
+ *
+ * Single source of truth for model metadata. The full `ModelDefinition` is
+ * consumed both by server-side code (chat handler, compaction) and over the
+ * wire by `GET /ai/models`. Nothing in this shape is sensitive enough to hide
+ * from authenticated clients today; if that changes, introduce a `PublicModel`
+ * projection here and have the handler convert before responding.
+ *
+ * @module
+ */
+export {};

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@molecule/api-resource-ai-models",
+  "version": "1.0.0",
+  "description": "AI model catalog — server-side source of truth plus an authentication-gated discovery endpoint",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "molecule",
+    "ai",
+    "models"
+  ],
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@molecule/api-bond": "1.0.0",
+    "@molecule/api-i18n": "1.0.0",
+    "@molecule/api-resource": "1.0.0",
+    "@types/node": "26.1.2",
+    "typescript": "6.0.3",
+    "vitest": "4.1.10"
+  },
+  "peerDependencies": {
+    "@molecule/api-bond": "^1.0.0",
+    "@molecule/api-i18n": "^1.0.0",
+    "@molecule/api-resource": "^1.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@molecule/api-i18n": {
+      "optional": true
+    },
+    "@molecule/api-resource": {
+      "optional": true
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/molecule-dev/molecule.git",
+    "directory": "packages/api/resources/ai-models"
+  },
+  "homepage": "https://github.com/molecule-dev/molecule/tree/main/packages/api/resources/ai-models",
+  "bugs": "https://github.com/molecule-dev/molecule/issues",
+  "publishConfig": {
+    "access": "public"
+  }
+}