@wrongstack/core 0.298.1 → 0.298.2

package/dist/infrastructure/index.js

@@ -3632,13 +3632,32 @@ function inlineDefinition(model) {
   if (maxOutput !== void 0) definition.maxOutput = maxOutput;
   const capabilities = readCapabilities(model);
   if (capabilities) definition.capabilities = capabilities;
+  const { id: _id, ...rest } = model;
+  if (Object.keys(rest).length > 0) {
+    definition.modelsDev = rest;
+  }
   return definition;
 }
 function mergeDefinitions(base, patch) {
+  const mergedModelsDev = (() => {
+    if (!base?.modelsDev && !patch.modelsDev) return void 0;
+    const baseMd = base?.modelsDev ?? {};
+    const patchMd = patch.modelsDev ?? {};
+    const result = { ...baseMd, ...patchMd };
+    for (const nestedKey of ["limit", "cost", "modalities"]) {
+      const bn = baseMd?.[nestedKey];
+      const pn = patchMd?.[nestedKey];
+      if (bn || pn) {
+        result[nestedKey] = { ...bn ?? {}, ...pn ?? {} };
+      }
+    }
+    return result;
+  })();
   return {
     ...base,
     ...patch,
-    ...base?.capabilities || patch.capabilities ? { capabilities: { ...base?.capabilities, ...patch.capabilities } } : {}
+    ...base?.capabilities || patch.capabilities ? { capabilities: { ...base?.capabilities, ...patch.capabilities } } : {},
+    ...mergedModelsDev ? { modelsDev: mergedModelsDev } : {}
   };
 }
 function normalizeInlineProviderModels(config, warn) {

package/dist/models/index.d.ts

@@ -5,6 +5,7 @@ export { LLMSelector, type LLMSelectorOptions } from './llm-selector.js';
 export { resolveProviderModelList, describeCatalogModel, type ProviderModelDescriptor, } from './provider-model-resolve.js';
 export { CODEX_MODELS, codexModelMeta, type CodexModelMeta } from './codex-catalog.js';
 export { ALIBABA_TOKEN_PLAN_MODELS, alibabaTokenPlanModelMeta, type AlibabaTokenPlanModelMeta, } from './alibaba-token-plan-catalog.js';
+export { MODELS_DEV_MODALITY_VALUES, modelsDevCostSchema, modelsDevLimitSchema, modelsDevModalitiesSchema, modelsDevModelSchema, modelsDevPayloadSchema, modelsDevProviderSchema, type ModelsDevModelParsed, type ModelsDevPayloadParsed, type ModelsDevProviderParsed, type ModelsDevSchemaSyncProof, } from './models-dev-schema.js';
 export { MODEL_PROFILES, TASK_TO_ROLE, inferTaskType, findModelProfile, scoreModelForTask, type ModelProfile, type TaskType, } from './model-intelligence.js';
 export { ModelRouter, type RouterConfig, type ModelPick, type RouterCosts, type ModelIntelligenceEntry, } from './model-router.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/models/index.js

@@ -504,7 +504,7 @@ function stripUndefined(obj) {
 // src/models/models-registry.ts
 var DEFAULT_URL = "https://models.dev/api.json";
 var ENV_URL_KEY = "WRONGSTACK_MODELS_DEV_URL";
-var DEFAULT_TTL_SECONDS = 24 * 3600;
+var DEFAULT_TTL_SECONDS = 3 * 3600;
 var DEFAULT_REFRESH_TIMEOUT_MS = 15e3;
 var FAMILY_BY_NPM = {
   "@ai-sdk/anthropic": "anthropic",
@@ -1801,6 +1801,106 @@ function alibabaTokenPlanModelMeta(id) {
   return BY_ID2.get(id);
 }
 
+// src/models/models-dev-schema.ts
+import { z } from "zod";
+
+// src/utils/deep-merge.ts
+var FORBIDDEN_PROTO_KEYS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype",
+  "__defineGetter__",
+  "__defineSetter__",
+  "__lookupGetter__",
+  "__lookupSetter__"
+]);
+
+// src/models/models-dev-schema.ts
+var MODELS_DEV_MODALITY_VALUES = ["text", "image", "audio", "video", "pdf"];
+var REASONING_EFFORT_LITERALS = [
+  "none",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+var nonNegativeInt = z.number().int().nonnegative();
+var finiteNumber = z.number().finite();
+var modelsDevLimitSchema = z.looseObject({
+  context: nonNegativeInt.optional(),
+  output: nonNegativeInt.optional(),
+  input: nonNegativeInt.optional()
+});
+var modelsDevCostSchema = z.looseObject({
+  input: finiteNumber.optional(),
+  output: finiteNumber.optional(),
+  cache_read: finiteNumber.optional(),
+  cache_write: finiteNumber.optional(),
+  cache_write_5m: finiteNumber.optional(),
+  cache_write_1h: finiteNumber.optional(),
+  context_over_200k: finiteNumber.optional(),
+  reasoning: finiteNumber.optional(),
+  input_audio: finiteNumber.optional(),
+  output_audio: finiteNumber.optional()
+});
+var modelsDevModalitiesSchema = z.looseObject({
+  input: z.array(z.string().min(1)).optional(),
+  output: z.array(z.string().min(1)).optional()
+});
+var reasoningOptionSchema = z.union([
+  z.looseObject({ type: z.literal("toggle") }),
+  z.looseObject({
+    type: z.literal("effort"),
+    // Closed on purpose: effort literals are a runtime concept consumed via
+    // ReasoningEffort (types/provider.ts). Keep this list in sync with that
+    // union — a new upstream literal should update BOTH deliberately (the
+    // compile-time sync proof below is designed to fail loudly on drift).
+    values: z.array(z.enum(REASONING_EFFORT_LITERALS)).optional()
+  }),
+  z.looseObject({
+    type: z.literal("budget_tokens"),
+    min: z.number().optional(),
+    max: z.number().optional()
+  })
+]);
+var protoKeyRefinement = (label) => ({
+  message: `${label} id is a forbidden prototype-pollution key`
+});
+var modelsDevModelSchema = z.looseObject({
+  id: z.string().min(1).refine((id) => !FORBIDDEN_PROTO_KEYS.has(id), protoKeyRefinement("Model")),
+  name: z.string().min(1),
+  description: z.string().optional(),
+  family: z.string().optional(),
+  attachment: z.boolean().optional(),
+  reasoning: z.boolean().optional(),
+  reasoning_options: z.union([reasoningOptionSchema, z.array(reasoningOptionSchema)]).optional(),
+  interleaved: z.union([z.boolean(), z.looseObject({ field: z.string().optional() })]).optional(),
+  tool_call: z.boolean().optional(),
+  structured_output: z.boolean().optional(),
+  temperature: z.boolean().optional(),
+  knowledge: z.string().optional(),
+  release_date: z.string().optional(),
+  last_updated: z.string().optional(),
+  open_weights: z.boolean().optional(),
+  modalities: modelsDevModalitiesSchema.optional(),
+  cost: modelsDevCostSchema.optional(),
+  limit: modelsDevLimitSchema.optional(),
+  status: z.string().optional(),
+  experimental: z.boolean().optional()
+});
+var modelsDevProviderSchema = z.looseObject({
+  id: z.string().min(1).refine((id) => !FORBIDDEN_PROTO_KEYS.has(id), protoKeyRefinement("Provider")),
+  name: z.string().min(1),
+  env: z.array(z.string()).optional(),
+  npm: z.string().optional(),
+  api: z.string().optional(),
+  doc: z.string().optional(),
+  models: z.record(z.string(), modelsDevModelSchema)
+});
+var modelsDevPayloadSchema = z.record(z.string(), modelsDevProviderSchema);
+
 // src/models/model-intelligence.ts
 var MODEL_PROFILES = [
   // ── Anthropic ──
@@ -2297,6 +2397,7 @@ export {
   DefaultModeStore,
   DefaultModelsRegistry,
   LLMSelector,
+  MODELS_DEV_MODALITY_VALUES,
   MODEL_PROFILES,
   ModelRouter,
   TASK_TO_ROLE,
@@ -2308,6 +2409,12 @@ export {
   inferTaskType,
   loadProjectModes,
   loadUserModes,
+  modelsDevCostSchema,
+  modelsDevLimitSchema,
+  modelsDevModalitiesSchema,
+  modelsDevModelSchema,
+  modelsDevPayloadSchema,
+  modelsDevProviderSchema,
   resolveProviderModelList,
   scoreModelForTask
 };

package/dist/models/models-dev-schema.d.ts

@@ -0,0 +1,308 @@
+/**
+ * Runtime-validated mirror of the models.dev/api.json schema.
+ *
+ * ME-1 (Model Editor board): one zod schema pair shared by config-loader
+ * validation, WS payloads, WebUI forms, and TUI validation. The static type
+ * mirror lives in `../types/models-registry.js` (ModelsDevModel /
+ * ModelsDevProvider); the compile-time assertion at the bottom of this file
+ * keeps parsed schema output assignable to the static mirror.
+ *
+ * Passthrough policy: models.dev keeps adding fields (`limit.input`,
+ * `cost.tiers`, `reasoning_options` are recent examples), so every object
+ * schema below is LOOSE — unknown keys are accepted and preserved, never
+ * stripped or rejected. Known keys are type-checked; unknown ones pass.
+ *
+ * Modalities are plain string arrays upstream ("text" | "image" | "audio" |
+ * "video" | "pdf" observed in the 2026-08-03 census). The schema validates
+ * "array of non-empty strings" rather than a closed enum so new upstream
+ * modality values don't break parsing; MODELS_DEV_MODALITY_VALUES documents
+ * the known set for UI/editor use.
+ */
+import { z } from 'zod';
+import type { ModelsDevModel, ModelsDevProvider } from '../types/models-registry.js';
+/** Known values observed in models.dev modality arrays (2026-08-03 census). */
+export declare const MODELS_DEV_MODALITY_VALUES: readonly ['text', 'image', 'audio', 'video', 'pdf'];
+/** `limit` — context/output on every model; `input` on a subset. 0 is valid. */
+export declare const modelsDevLimitSchema: z.ZodObject<{
+    context: z.ZodOptional<z.ZodNumber>;
+    output: z.ZodOptional<z.ZodNumber>;
+    input: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+/**
+ * `cost` — USD per 1M tokens upstream. Known numeric keys are validated;
+ * non-numeric additions like `tiers` (observed on ~300 models) pass through
+ * untouched via the loose object.
+ */
+export declare const modelsDevCostSchema: z.ZodObject<{
+    input: z.ZodOptional<z.ZodNumber>;
+    output: z.ZodOptional<z.ZodNumber>;
+    cache_read: z.ZodOptional<z.ZodNumber>;
+    cache_write: z.ZodOptional<z.ZodNumber>;
+    cache_write_5m: z.ZodOptional<z.ZodNumber>;
+    cache_write_1h: z.ZodOptional<z.ZodNumber>;
+    context_over_200k: z.ZodOptional<z.ZodNumber>;
+    reasoning: z.ZodOptional<z.ZodNumber>;
+    input_audio: z.ZodOptional<z.ZodNumber>;
+    output_audio: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+/** `modalities` — plain string arrays; new values accepted (see file docs). */
+export declare const modelsDevModalitiesSchema: z.ZodObject<{
+    input: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    output: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;
+/** One models.dev model entry (values of `provider.models`). */
+export declare const modelsDevModelSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    family: z.ZodOptional<z.ZodString>;
+    attachment: z.ZodOptional<z.ZodBoolean>;
+    reasoning: z.ZodOptional<z.ZodBoolean>;
+    reasoning_options: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"toggle">;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"effort">;
+        values: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            high: "high";
+            low: "low";
+            max: "max";
+            medium: "medium";
+            minimal: "minimal";
+            none: "none";
+            xhigh: "xhigh";
+        }>>>;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"budget_tokens">;
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>]>, z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"toggle">;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"effort">;
+        values: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            high: "high";
+            low: "low";
+            max: "max";
+            medium: "medium";
+            minimal: "minimal";
+            none: "none";
+            xhigh: "xhigh";
+        }>>>;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"budget_tokens">;
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>]>>]>>;
+    interleaved: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+        field: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>]>>;
+    tool_call: z.ZodOptional<z.ZodBoolean>;
+    structured_output: z.ZodOptional<z.ZodBoolean>;
+    temperature: z.ZodOptional<z.ZodBoolean>;
+    knowledge: z.ZodOptional<z.ZodString>;
+    release_date: z.ZodOptional<z.ZodString>;
+    last_updated: z.ZodOptional<z.ZodString>;
+    open_weights: z.ZodOptional<z.ZodBoolean>;
+    modalities: z.ZodOptional<z.ZodObject<{
+        input: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        output: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$loose>>;
+    cost: z.ZodOptional<z.ZodObject<{
+        input: z.ZodOptional<z.ZodNumber>;
+        output: z.ZodOptional<z.ZodNumber>;
+        cache_read: z.ZodOptional<z.ZodNumber>;
+        cache_write: z.ZodOptional<z.ZodNumber>;
+        cache_write_5m: z.ZodOptional<z.ZodNumber>;
+        cache_write_1h: z.ZodOptional<z.ZodNumber>;
+        context_over_200k: z.ZodOptional<z.ZodNumber>;
+        reasoning: z.ZodOptional<z.ZodNumber>;
+        input_audio: z.ZodOptional<z.ZodNumber>;
+        output_audio: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>;
+    limit: z.ZodOptional<z.ZodObject<{
+        context: z.ZodOptional<z.ZodNumber>;
+        output: z.ZodOptional<z.ZodNumber>;
+        input: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>;
+    status: z.ZodOptional<z.ZodString>;
+    experimental: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+/** One models.dev provider entry (top-level values of api.json). */
+export declare const modelsDevProviderSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    env: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    npm: z.ZodOptional<z.ZodString>;
+    api: z.ZodOptional<z.ZodString>;
+    doc: z.ZodOptional<z.ZodString>;
+    models: z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        family: z.ZodOptional<z.ZodString>;
+        attachment: z.ZodOptional<z.ZodBoolean>;
+        reasoning: z.ZodOptional<z.ZodBoolean>;
+        reasoning_options: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodLiteral<"toggle">;
+        }, z.core.$loose>, z.ZodObject<{
+            type: z.ZodLiteral<"effort">;
+            values: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                high: "high";
+                low: "low";
+                max: "max";
+                medium: "medium";
+                minimal: "minimal";
+                none: "none";
+                xhigh: "xhigh";
+            }>>>;
+        }, z.core.$loose>, z.ZodObject<{
+            type: z.ZodLiteral<"budget_tokens">;
+            min: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>]>, z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodLiteral<"toggle">;
+        }, z.core.$loose>, z.ZodObject<{
+            type: z.ZodLiteral<"effort">;
+            values: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                high: "high";
+                low: "low";
+                max: "max";
+                medium: "medium";
+                minimal: "minimal";
+                none: "none";
+                xhigh: "xhigh";
+            }>>>;
+        }, z.core.$loose>, z.ZodObject<{
+            type: z.ZodLiteral<"budget_tokens">;
+            min: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>]>>]>>;
+        interleaved: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+            field: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>]>>;
+        tool_call: z.ZodOptional<z.ZodBoolean>;
+        structured_output: z.ZodOptional<z.ZodBoolean>;
+        temperature: z.ZodOptional<z.ZodBoolean>;
+        knowledge: z.ZodOptional<z.ZodString>;
+        release_date: z.ZodOptional<z.ZodString>;
+        last_updated: z.ZodOptional<z.ZodString>;
+        open_weights: z.ZodOptional<z.ZodBoolean>;
+        modalities: z.ZodOptional<z.ZodObject<{
+            input: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            output: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$loose>>;
+        cost: z.ZodOptional<z.ZodObject<{
+            input: z.ZodOptional<z.ZodNumber>;
+            output: z.ZodOptional<z.ZodNumber>;
+            cache_read: z.ZodOptional<z.ZodNumber>;
+            cache_write: z.ZodOptional<z.ZodNumber>;
+            cache_write_5m: z.ZodOptional<z.ZodNumber>;
+            cache_write_1h: z.ZodOptional<z.ZodNumber>;
+            context_over_200k: z.ZodOptional<z.ZodNumber>;
+            reasoning: z.ZodOptional<z.ZodNumber>;
+            input_audio: z.ZodOptional<z.ZodNumber>;
+            output_audio: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
+        limit: z.ZodOptional<z.ZodObject<{
+            context: z.ZodOptional<z.ZodNumber>;
+            output: z.ZodOptional<z.ZodNumber>;
+            input: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
+        status: z.ZodOptional<z.ZodString>;
+        experimental: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+/** The whole api.json payload: provider id → provider entry. */
+export declare const modelsDevPayloadSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    env: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    npm: z.ZodOptional<z.ZodString>;
+    api: z.ZodOptional<z.ZodString>;
+    doc: z.ZodOptional<z.ZodString>;
+    models: z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        family: z.ZodOptional<z.ZodString>;
+        attachment: z.ZodOptional<z.ZodBoolean>;
+        reasoning: z.ZodOptional<z.ZodBoolean>;
+        reasoning_options: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodLiteral<"toggle">;
+        }, z.core.$loose>, z.ZodObject<{
+            type: z.ZodLiteral<"effort">;
+            values: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                high: "high";
+                low: "low";
+                max: "max";
+                medium: "medium";
+                minimal: "minimal";
+                none: "none";
+                xhigh: "xhigh";
+            }>>>;
+        }, z.core.$loose>, z.ZodObject<{
+            type: z.ZodLiteral<"budget_tokens">;
+            min: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>]>, z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodLiteral<"toggle">;
+        }, z.core.$loose>, z.ZodObject<{
+            type: z.ZodLiteral<"effort">;
+            values: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                high: "high";
+                low: "low";
+                max: "max";
+                medium: "medium";
+                minimal: "minimal";
+                none: "none";
+                xhigh: "xhigh";
+            }>>>;
+        }, z.core.$loose>, z.ZodObject<{
+            type: z.ZodLiteral<"budget_tokens">;
+            min: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>]>>]>>;
+        interleaved: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+            field: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>]>>;
+        tool_call: z.ZodOptional<z.ZodBoolean>;
+        structured_output: z.ZodOptional<z.ZodBoolean>;
+        temperature: z.ZodOptional<z.ZodBoolean>;
+        knowledge: z.ZodOptional<z.ZodString>;
+        release_date: z.ZodOptional<z.ZodString>;
+        last_updated: z.ZodOptional<z.ZodString>;
+        open_weights: z.ZodOptional<z.ZodBoolean>;
+        modalities: z.ZodOptional<z.ZodObject<{
+            input: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            output: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$loose>>;
+        cost: z.ZodOptional<z.ZodObject<{
+            input: z.ZodOptional<z.ZodNumber>;
+            output: z.ZodOptional<z.ZodNumber>;
+            cache_read: z.ZodOptional<z.ZodNumber>;
+            cache_write: z.ZodOptional<z.ZodNumber>;
+            cache_write_5m: z.ZodOptional<z.ZodNumber>;
+            cache_write_1h: z.ZodOptional<z.ZodNumber>;
+            context_over_200k: z.ZodOptional<z.ZodNumber>;
+            reasoning: z.ZodOptional<z.ZodNumber>;
+            input_audio: z.ZodOptional<z.ZodNumber>;
+            output_audio: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
+        limit: z.ZodOptional<z.ZodObject<{
+            context: z.ZodOptional<z.ZodNumber>;
+            output: z.ZodOptional<z.ZodNumber>;
+            input: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
+        status: z.ZodOptional<z.ZodString>;
+        experimental: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>;
+}, z.core.$loose>>;
+export type ModelsDevModelParsed = z.infer<typeof modelsDevModelSchema>;
+export type ModelsDevProviderParsed = z.infer<typeof modelsDevProviderSchema>;
+export type ModelsDevPayloadParsed = z.infer<typeof modelsDevPayloadSchema>;
+type AssertAssignableTo<T, U extends T> = U;
+type ModelSchemaSyncCheck = AssertAssignableTo<ModelsDevModel, ModelsDevModelParsed>;
+type ProviderSchemaSyncCheck = AssertAssignableTo<ModelsDevProvider, ModelsDevProviderParsed>;
+export type ModelsDevSchemaSyncProof = [ModelSchemaSyncCheck, ProviderSchemaSyncCheck];
+export {};
+//# sourceMappingURL=models-dev-schema.d.ts.map

package/dist/plugin/index.js

@@ -6839,7 +6839,7 @@ function trimKnownFingerprints(map, max) {
     map.delete(oldest);
   }
 }
-function buildReviewerModelPool(provider, model, fallbackModels = []) {
+function buildReviewerModelPool(provider, model, fallbackModels = [], statusTracker) {
   const primaryProvider = provider.trim();
   const primaryModel = model.trim();
   const primaryRef = primaryProvider && primaryModel ? `${primaryProvider}/${primaryModel}` : "";
@@ -6854,12 +6854,20 @@ function buildReviewerModelPool(provider, model, fallbackModels = []) {
     if (seen.has(normalized)) continue;
     seen.add(ref);
     seen.add(normalized);
+    if (statusTracker && !statusTracker.isAvailable(parsed.provider.trim(), parsed.model.trim())) {
+      continue;
+    }
     pool.push(normalized);
   }
   return pool;
 }
-function selectRoundRobinReviewerAssignment(pool, cursor, fallbackProvider = "", fallbackModel = "") {
-  if (pool.length === 0) {
+function selectRoundRobinReviewerAssignment(pool, cursor, fallbackProvider = "", fallbackModel = "", statusTracker) {
+  const filteredPool = statusTracker ? pool.filter((ref) => {
+    const parsed2 = parseModelRef(ref);
+    if (!parsed2.provider?.trim() || !parsed2.model.trim()) return false;
+    return statusTracker.isAvailable(parsed2.provider.trim(), parsed2.model.trim());
+  }) : pool;
+  if (filteredPool.length === 0) {
     return {
       provider: fallbackProvider,
       model: fallbackModel,
@@ -6867,13 +6875,13 @@ function selectRoundRobinReviewerAssignment(pool, cursor, fallbackProvider = "",
       nextCursor: cursor + 1
     };
   }
-  const len = pool.length;
+  const len = filteredPool.length;
   const idx = (cursor % len + len) % len;
-  const primaryRef = pool[idx];
+  const primaryRef = filteredPool[idx];
   const parsed = parseModelRef(primaryRef);
   const provider = parsed.provider?.trim() || fallbackProvider;
   const model = parsed.model.trim() || fallbackModel;
-  const fallbackModels = [...pool.slice(idx + 1), ...pool.slice(0, idx)];
+  const fallbackModels = [...filteredPool.slice(idx + 1), ...filteredPool.slice(0, idx)];
   return {
     provider,
     model,

package/dist/plugins/auto-review-plugin.d.ts

@@ -1,3 +1,4 @@
+import type { ProviderModelStatusTracker } from '../coordination/provider-status-tracker.js';
 import type { Config } from '../types/config.js';
 import type { Plugin } from '../types/plugin.js';
 import type { CascadeAgentKind } from './chimera-plugin.js';
@@ -70,8 +71,15 @@ export interface ReviewerModelAssignment {
  *
  * Order is stable: configured primary first, then the fallback chain.
  * Entries must be `provider/model` (or parseable refs); bare blanks are dropped.
+ *
+ * When a {@link ProviderModelStatusTracker} is supplied, every entry that is
+ * currently `state: 'blocked'` (waiting-room / token-reset-limit room) is
+ * filtered out before the pool is returned. Without this filter, concurrent
+ * Chimera reviewers would re-spawn on a 429-stricken model on every round-
+ * robin turn and burn the entire chain instead of leaving the doomed model
+ * quarantined until the tracker re-admits it.
  */
-export declare function buildReviewerModelPool(provider: string, model: string, fallbackModels?: readonly string[]): string[];
+export declare function buildReviewerModelPool(provider: string, model: string, fallbackModels?: readonly string[], statusTracker?: ProviderModelStatusTracker | undefined): string[];
 /**
  * Pick primary + fallback chain for the Nth concurrent reviewer via round-robin.
  *
@@ -79,11 +87,18 @@ export declare function buildReviewerModelPool(provider: string, model: string,
  * rotated so the former primary lands last (still available after rate limits).
  * The pool must be pre-filtered by {@link buildReviewerModelPool} so every
  * non-empty entry contains both a provider and a model.
+ *
+ * When a {@link ProviderModelStatusTracker} is supplied, the cursor advances
+ * over blocked entries too — a doomed entry is never picked as the primary,
+ * but the cursor saturates against the live pool so the next-after-blocked
+ * round inherits the rest of the unwalked chain instead of looping back to
+ * the head. Without the tracker, the cursor advances mod `pool.length`,
+ * which is the pre-waiting-room behavior.
  * Pure: the caller owns the cursor (typically a process-local counter).
  */
 export declare function selectRoundRobinReviewerAssignment(pool: readonly string[], cursor: number, 
 /** Used only when the selected ref is somehow unparseable — defensive. */
-fallbackProvider?: string, fallbackModel?: string): ReviewerModelAssignment;
+fallbackProvider?: string, fallbackModel?: string, statusTracker?: ProviderModelStatusTracker | undefined): ReviewerModelAssignment;
 export declare function resolveAutoReviewConfig(cfg: AutoReviewConfig, sessionConfig: Config): ResolvedAutoReviewConfig;
 export interface ParsedSeverities {
     critical: number;

package/dist/storage/index.js

@@ -6216,13 +6216,32 @@ function inlineDefinition(model) {
   if (maxOutput !== void 0) definition.maxOutput = maxOutput;
   const capabilities = readCapabilities(model);
   if (capabilities) definition.capabilities = capabilities;
+  const { id: _id, ...rest } = model;
+  if (Object.keys(rest).length > 0) {
+    definition.modelsDev = rest;
+  }
   return definition;
 }
 function mergeDefinitions(base, patch) {
+  const mergedModelsDev = (() => {
+    if (!base?.modelsDev && !patch.modelsDev) return void 0;
+    const baseMd = base?.modelsDev ?? {};
+    const patchMd = patch.modelsDev ?? {};
+    const result = { ...baseMd, ...patchMd };
+    for (const nestedKey of ["limit", "cost", "modalities"]) {
+      const bn = baseMd?.[nestedKey];
+      const pn = patchMd?.[nestedKey];
+      if (bn || pn) {
+        result[nestedKey] = { ...bn ?? {}, ...pn ?? {} };
+      }
+    }
+    return result;
+  })();
   return {
     ...base,
     ...patch,
-    ...base?.capabilities || patch.capabilities ? { capabilities: { ...base?.capabilities, ...patch.capabilities } } : {}
+    ...base?.capabilities || patch.capabilities ? { capabilities: { ...base?.capabilities, ...patch.capabilities } } : {},
+    ...mergedModelsDev ? { modelsDev: mergedModelsDev } : {}
   };
 }
 function normalizeInlineProviderModels(config, warn) {