@yeaft/webchat-agent 0.1.923 → 0.1.925

package/index.js

@@ -324,10 +324,22 @@ process.on('SIGTERM', () => {
   process.exit(0);
 });
 
-// 启动 - 先确保依赖，再检测能力，再连接
+// 启动 - 先确保依赖，再检测能力，预热 models.dev 缓存，再连接
 (async () => {
   await ensureDependencies();
   await ensureYeaftSkills();
   ctx.agentCapabilities = await detectCapabilities();
+  // Prime the models.dev community catalog so the Yeaft engine's *synchronous*
+  // hot path (engine.js / config.js / cli.js all read context-window inline)
+  // can resolve real per-model limits without bubbling async up through every
+  // call site. Failure here is non-fatal: stale disk cache → DEFAULT 200K
+  // fall-through keeps the agent boot-able offline.
+  try {
+    const { fetchModelsDev } = await import('./yeaft/llm/models-dev.js');
+    await fetchModelsDev({ yeaftDir: YEAFT_DIR });
+    console.log('[Agent] models.dev cache primed');
+  } catch (err) {
+    console.warn(`[Agent] models.dev prime failed (will use config/defaults): ${err?.message || err}`);
+  }
   connect();
 })();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.923",
+  "version": "0.1.925",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

package/yeaft/cli.js

@@ -28,7 +28,7 @@ import { join } from 'path';
 import { loadConfig } from './config.js';
 import { DebugTrace } from './debug-trace.js';
 import { loadSession } from './session.js';
-import { listModels, resolveModel, parseModelRef } from './models.js';
+import { listModels, resolveModel, parseModelRef, resolveContextWindow, resolveMaxOutputTokens } from './models.js';
 import { buildSystemPrompt } from './prompts.js';
 import { searchMessages } from './conversation/search.js';
 import { ConversationStore } from './conversation/persist.js';
@@ -488,13 +488,15 @@ async function runREPL(config, args) {
                 session.config.model = modelRef;
               }
 
-              // Re-resolve model info from registry
+              // Re-resolve model info from registry (adapter / baseUrl /
+              // thinking metadata). Token limits come from the resolver
+              // ladder — models.dev snapshot first, config fallback.
               const newModelInfo = resolveModel(session.config.model);
               if (newModelInfo) {
-                session.config.maxContextTokens = newModelInfo.contextWindow;
-                session.config.maxOutputTokens = newModelInfo.maxOutputTokens;
                 session.config.modelInfo = newModelInfo;
               }
+              session.config.maxContextTokens = resolveContextWindow(session.config.model, session.config);
+              session.config.maxOutputTokens = resolveMaxOutputTokens(session.config.model, session.config);
               const providerStr = providerName ? ` (provider: ${providerName})` : '';
               console.log(`Model switched to: ${session.config.model}${providerStr}`);
               console.log('Note: Model change takes effect on next query.');
@@ -766,6 +768,19 @@ async function runOnce(config, args) {
 async function main() {
   const args = parseArgs(process.argv);
 
+  // Prime the models.dev community catalog so resolveContextWindow /
+  // resolveMaxOutputTokens — called synchronously from loadConfig and the
+  // engine hot path — can return real per-model limits instead of falling
+  // through to DEFAULT. Failure is non-fatal: stale disk cache or DEFAULT
+  // keeps the CLI usable offline. Mirrors the prime in agent/index.js.
+  try {
+    const { fetchModelsDev } = await import('./llm/models-dev.js');
+    const dir = args.dir || process.env.YEAFT_DIR || null;
+    await fetchModelsDev({ yeaftDir: dir });
+  } catch {
+    // best-effort; resolver falls back to config / DEFAULT.
+  }
+
   // Load config with CLI overrides (for --trace queries and dry-run, no session needed)
   const config = loadConfig({
     model: args.model,

package/yeaft/config.js

@@ -22,7 +22,7 @@
 import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 import { DEFAULT_YEAFT_DIR } from './init.js';
-import { resolveModel, parseModelRef, normalizeProviderModels } from './models.js';
+import { resolveModel, parseModelRef, normalizeProviderModels, resolveContextWindow, resolveMaxOutputTokens } from './models.js';
 
 /** Default configuration values. */
 const DEFAULTS = {
@@ -250,8 +250,15 @@ function loadLegacyConfig(dir, overrides) {
     if (modelInfo) {
       config.adapter = modelInfo.adapter === 'anthropic' ? 'anthropic' : 'openai';
       if (!config.baseUrl) config.baseUrl = modelInfo.baseUrl;
-      if (config.maxContextTokens === DEFAULTS.maxContextTokens) config.maxContextTokens = modelInfo.contextWindow;
-      if (config.maxOutputTokens === DEFAULTS.maxOutputTokens) config.maxOutputTokens = modelInfo.maxOutputTokens;
+      // Resolve token limits via the resolver ladder (models.dev → config →
+      // DEFAULT). Only fill in when the caller left the slot at the default
+      // — explicit env / CLI overrides win.
+      if (config.maxContextTokens === DEFAULTS.maxContextTokens) {
+        config.maxContextTokens = resolveContextWindow(config.model, config);
+      }
+      if (config.maxOutputTokens === DEFAULTS.maxOutputTokens) {
+        config.maxOutputTokens = resolveMaxOutputTokens(config.model, config);
+      }
     } else {
       if (config.apiKey) config.adapter = 'anthropic';
       else if (config.openaiApiKey) config.adapter = 'openai';
@@ -305,9 +312,19 @@ export function loadConfig(overrides = {}) {
     fastModelId = parsed.modelId;
   }
 
-  // Resolve model info for context window / output limits
+  // Resolve model info for adapter/baseUrl/thinking metadata. Token limits
+  // (contextWindow / maxOutputTokens) are NOT read from here — they live in
+  // models.dev and are resolved via resolveContextWindow / resolveMaxOutputTokens
+  // a few lines below so the live models.dev snapshot is the source of truth.
   const modelInfo = resolveModel(model);
 
+  // Pre-resolve token limits once so we can both write them onto config and
+  // pass `config` to the resolver chain consistently below.
+  const resolvedMaxContext = overrides.maxContextTokens ?? jsonConfig.maxContextTokens
+    ?? resolveContextWindow(model, { modelInfo });
+  const resolvedMaxOutput = overrides.maxOutputTokens ?? jsonConfig.maxOutputTokens
+    ?? resolveMaxOutputTokens(model, { modelInfo });
+
   const config = {
     // Model
     model: overrides.model || model,
@@ -325,9 +342,16 @@ export function loadConfig(overrides = {}) {
     debug: overrides.debug !== undefined ? overrides.debug : (jsonConfig.debug ?? DEFAULTS.debug),
     dir,
 
-    // Token limits
-    maxContextTokens: overrides.maxContextTokens ?? jsonConfig.maxContextTokens ?? modelInfo?.contextWindow ?? DEFAULTS.maxContextTokens,
-    maxOutputTokens: overrides.maxOutputTokens ?? jsonConfig.maxOutputTokens ?? modelInfo?.maxOutputTokens ?? DEFAULTS.maxOutputTokens,
+    // Token limits. Resolution order:
+    //   1. CLI override (overrides.*)
+    //   2. ~/.yeaft/config.json explicit value
+    //   3. resolveContextWindow / resolveMaxOutputTokens — which themselves
+    //      walk: per-provider override → models.dev snapshot → DEFAULT.
+    // Anything that needs the *live* number for a model the user picks at
+    // runtime (mid-session model switch, e.g.) should call the resolvers
+    // directly rather than read these fields.
+    maxContextTokens: resolvedMaxContext,
+    maxOutputTokens: resolvedMaxOutput,
     messageTokenBudget: overrides.messageTokenBudget ?? jsonConfig.messageTokenBudget ?? DEFAULTS.messageTokenBudget,
     maxContinueTurns: overrides.maxContinueTurns ?? jsonConfig.maxContinueTurns ?? DEFAULTS.maxContinueTurns,
 

package/yeaft/engine.js

@@ -37,6 +37,7 @@ import { runStopHooks } from './stop-hooks.js';
 const MAIN_THREAD_ID = 'main';
 import { pickEffort, parseEffortPrefix } from './effort.js';
 import { DEFAULT_CONTEXT_WINDOW, normalizeEffort, resolveContextWindow, resolveModel } from './models.js';
+import { lookupModelLimitSync } from './llm/models-dev.js';
 import { countTurns } from './turn-utils.js';
 import { attachRouterPlan, extractPriorPlan, stripMetaForWire } from './router/continuity.js';
 import { resolveThinking } from './router/thinking.js';
@@ -186,7 +187,11 @@ export function shouldAllowGroupReflection({
     };
   }
   const contextWindow = resolveContextWindow(model, config);
-  const hasRegistryContext = !!resolveModel(model)?.contextWindow;
+  // Telemetry: did the resolver hit either of its top non-default rungs?
+  // Used by `usedFallbackContextWindow` below — if neither models.dev nor
+  // the global config provided a number, we fell through to DEFAULT and
+  // callers may want to surface that to the user.
+  const hasModelsDevContext = !!lookupModelLimitSync(model, resolveModel(model)?.provider || null)?.context;
   const hasConfigContext = Number.isFinite(config?.maxContextTokens) && config.maxContextTokens > 0;
   const threshold = Math.floor(contextWindow * GROUP_CONTEXT_PRESSURE_RATIO);
   const tokenEstimate = estimateMessagesTokens(system, messages);
@@ -204,7 +209,7 @@ export function shouldAllowGroupReflection({
     contextWindow,
     ratio: GROUP_CONTEXT_PRESSURE_RATIO,
     turnCount,
-    usedFallbackContextWindow: !hasRegistryContext && !hasConfigContext && contextWindow === DEFAULT_CONTEXT_WINDOW,
+    usedFallbackContextWindow: !hasModelsDevContext && !hasConfigContext && contextWindow === DEFAULT_CONTEXT_WINDOW,
   };
 }
 

package/yeaft/llm/models-dev.js

@@ -163,6 +163,76 @@ export async function listProviderModels(providerId, { yeaftDir = null } = {}) {
   return Object.keys(models);
 }
 
+/**
+ * Synchronously look up a model's `{context, output}` limits from whatever
+ * models.dev snapshot is currently warmed in memory.
+ *
+ * The yeaft engine query loop is synchronous (engine.js, config.js, cli.js
+ * all read the context window inline). To avoid bubbling async up through
+ * every gate, the agent boot script primes `fetchModelsDev()` once so this
+ * function can read straight from `_memCache` afterwards.
+ *
+ * If the cache is empty (boot prime failed or test never warmed it), or the
+ * model isn't present in any provider entry, returns `null` — callers fall
+ * back to the next rung of their resolver ladder.
+ *
+ * Collision policy: a given model id can appear under multiple providers
+ * (e.g. `qwen3-32b` lives under 7 providers in the live models.dev snapshot
+ * with context limits ranging 32K–131K). Behavior:
+ *
+ *   • If `providerHint` is given AND that provider lists the model, we use
+ *     that provider's numbers verbatim — the caller knew which gateway it
+ *     was talking to.
+ *   • Otherwise we take the MIN of every provider's `context` and `output`.
+ *     Context is a ceiling: under-shooting risks an early compact (bad);
+ *     over-shooting risks an LLMContextError mid-query (worse). Min picks
+ *     the safer side. Users who know better can pin numbers explicitly via
+ *     `providers[].models[].contextWindow` in `~/.yeaft/config.json`.
+ *
+ * @param {string} modelId
+ * @param {string|null} [providerHint] Provider id matching the models.dev
+ *   top-level key (e.g. 'anthropic', 'openai', 'google', 'deepseek'). The
+ *   MODEL_REGISTRY's `provider` field is aligned to these ids deliberately.
+ * @returns {{ context?: number, output?: number } | null}
+ */
+export function lookupModelLimitSync(modelId, providerHint = null) {
+  if (!modelId || !_memCache || typeof _memCache !== 'object') return null;
+
+  // Hit the hint first if it actually lists this model.
+  if (providerHint && typeof providerHint === 'string') {
+    const provEntry = _memCache[providerHint];
+    const m = provEntry?.models?.[modelId];
+    if (m && m.limit && typeof m.limit === 'object') {
+      const out = {};
+      if (Number.isFinite(m.limit.context) && m.limit.context > 0) out.context = m.limit.context;
+      if (Number.isFinite(m.limit.output) && m.limit.output > 0) out.output = m.limit.output;
+      if (out.context !== undefined || out.output !== undefined) return out;
+    }
+    // Hint missed — fall through to the scan rather than returning null,
+    // because the model genuinely might live under another provider id
+    // (e.g. a deepseek model surfaced via a relay).
+  }
+
+  // Scan every provider; collect context/output values, return MIN.
+  let minCtx = null;
+  let minOut = null;
+  for (const provId of Object.keys(_memCache)) {
+    const m = _memCache[provId]?.models?.[modelId];
+    if (!m || !m.limit || typeof m.limit !== 'object') continue;
+    if (Number.isFinite(m.limit.context) && m.limit.context > 0) {
+      minCtx = minCtx === null ? m.limit.context : Math.min(minCtx, m.limit.context);
+    }
+    if (Number.isFinite(m.limit.output) && m.limit.output > 0) {
+      minOut = minOut === null ? m.limit.output : Math.min(minOut, m.limit.output);
+    }
+  }
+  if (minCtx === null && minOut === null) return null;
+  const result = {};
+  if (minCtx !== null) result.context = minCtx;
+  if (minOut !== null) result.output = minOut;
+  return result;
+}
+
 /**
  * Reset the in-memory cache. Test seam.
  */
@@ -171,3 +241,26 @@ export function _resetMemCache() {
   _memCachePath = null;
   _memCacheTime = 0;
 }
+
+/**
+ * Inject a snapshot into the in-memory cache without going through the
+ * fetch/disk path. Test seam: callers that want to exercise
+ * `lookupModelLimitSync` deterministically can seed any shape they need.
+ *
+ * Pass a falsy snapshot to fully reset (equivalent to {@link _resetMemCache}).
+ * This avoids the foot-gun where `_setMemCacheForTest(null)` would leave
+ * `_memCachePath` and `_memCacheTime` stamped to a fake `__test__` value,
+ * confusing any subsequent `fetchModelsDev` call about whether the cache
+ * was ever populated.
+ *
+ * @param {object|null} snapshot models.dev-shaped data, or null/undefined to reset.
+ */
+export function _setMemCacheForTest(snapshot) {
+  if (!snapshot || typeof snapshot !== 'object') {
+    _resetMemCache();
+    return;
+  }
+  _memCache = snapshot;
+  _memCachePath = '__test__';
+  _memCacheTime = Date.now();
+}

package/yeaft/models.js

@@ -1,24 +1,34 @@
 /**
- * models.js — Model ID registry for Yeaft Yeaft
+ * models.js — Model ID registry for Yeaft
  *
- * Maps model IDs (e.g. "gpt-5", "claude-sonnet-4-20250514") to their
- * adapter type, API base URL, and capabilities.
+ * Maps model IDs (e.g. "gpt-5", "claude-sonnet-4-20250514") to the *adapter*
+ * metadata Yeaft needs to dispatch requests: which protocol (anthropic vs
+ * openai-responses), which base URL, which thinking/reasoning capabilities.
  *
  * Yeaft does not provide its own models. The "model" field is always a
  * model ID from an external provider. This registry lets Yeaft auto-detect
  * the correct adapter and endpoint from just the model ID, so users only
  * need to set YEAFT_MODEL=gpt-5 without configuring adapter/baseUrl separately.
  *
+ * **Token limits (contextWindow / maxOutput) are NOT stored here.** They are
+ * resolved at runtime from the models.dev community catalog
+ * (`agent/yeaft/llm/models-dev.js`), with a per-provider config override
+ * (`~/.yeaft/config.json: providers[].models[].contextWindow`) and a
+ * conservative DEFAULT as the final rung. See {@link resolveContextWindow}
+ * and {@link resolveMaxOutputTokens} for the full ladder.
+ *
  * Unknown model IDs return null — caller falls back to env-based detection.
  */
 
+import { lookupModelLimitSync } from './llm/models-dev.js';
+
 /**
  * @typedef {Object} ModelInfo
- * @property {'anthropic' | 'openai' | 'deepseek' | 'google'} provider — Which provider this model belongs to
+ * @property {'anthropic' | 'openai' | 'deepseek' | 'google'} provider — Which provider this model belongs to.
+ *   These ids are intentionally aligned with the top-level keys in the models.dev
+ *   catalog so they can be used as a `providerHint` to {@link lookupModelLimitSync}.
  * @property {'anthropic' | 'chat-completions'} adapter — Which wire protocol to use
  * @property {string} baseUrl — Official API endpoint base URL
- * @property {number} contextWindow — Max context tokens
- * @property {number} maxOutputTokens — Max output tokens
  * @property {string} displayName — Human-readable model name
  * @property {boolean} [supportsThinking] — task-327a: model supports thinking/reasoning effort.
  * @property {'anthropic' | 'openai-reasoning' | 'none'} [thinkingProtocol] — task-327a:
@@ -39,8 +49,6 @@ export const MODEL_REGISTRY = new Map([
     provider: 'anthropic',
     adapter: 'anthropic',
     baseUrl: 'https://api.anthropic.com',
-    contextWindow: 200000,
-    maxOutputTokens: 16384,
     displayName: 'Claude Sonnet 4',
     // task-327a: extended thinking supported; budget caps at 32K on Sonnet.
     supportsThinking: true,
@@ -52,8 +60,6 @@ export const MODEL_REGISTRY = new Map([
     provider: 'anthropic',
     adapter: 'anthropic',
     baseUrl: 'https://api.anthropic.com',
-    contextWindow: 200000,
-    maxOutputTokens: 16384,
     displayName: 'Claude Opus 4',
     // task-327a: PM decision — Opus max budget = 64K.
     supportsThinking: true,
@@ -65,8 +71,6 @@ export const MODEL_REGISTRY = new Map([
     provider: 'anthropic',
     adapter: 'anthropic',
     baseUrl: 'https://api.anthropic.com',
-    contextWindow: 200000,
-    maxOutputTokens: 8192,
     displayName: 'Claude Haiku 3',
     // task-327a: Haiku 3 does not support extended thinking — effort is dropped.
     supportsThinking: false,
@@ -78,17 +82,12 @@ export const MODEL_REGISTRY = new Map([
     provider: 'openai',
     adapter: 'openai-responses',
     baseUrl: 'https://api.openai.com/v1',
-    contextWindow: 256000,
-    maxOutputTokens: 16384,
     displayName: 'GPT-5',
     // task-327a: GPT-5 supports reasoning.effort (low/medium/high). No 'max'.
     supportsThinking: true,
     thinkingProtocol: 'openai-reasoning',
     defaultEffort: null,
   }],
-  // gpt-5-mini/-nano/-pro: keep id + family/protocol metadata so they appear
-  // as known models, but do NOT hardcode context/maxOutput — the real limits
-  // should come from provider config (user-supplied) instead of guesses.
   ['gpt-5-mini', {
     provider: 'openai',
     adapter: 'openai-responses',
@@ -111,40 +110,30 @@ export const MODEL_REGISTRY = new Map([
     provider: 'openai',
     adapter: 'openai-responses',
     baseUrl: 'https://api.openai.com/v1',
-    contextWindow: 272000,
-    maxOutputTokens: 16384,
     displayName: 'GPT-5.4',
   }],
   ['gpt-4.1', {
     provider: 'openai',
     adapter: 'openai-responses',
     baseUrl: 'https://api.openai.com/v1',
-    contextWindow: 1047576,
-    maxOutputTokens: 32768,
     displayName: 'GPT-4.1',
   }],
   ['gpt-4.1-mini', {
     provider: 'openai',
     adapter: 'openai-responses',
     baseUrl: 'https://api.openai.com/v1',
-    contextWindow: 1047576,
-    maxOutputTokens: 16384,
     displayName: 'GPT-4.1 Mini',
   }],
   ['gpt-4.1-nano', {
     provider: 'openai',
     adapter: 'openai-responses',
     baseUrl: 'https://api.openai.com/v1',
-    contextWindow: 1047576,
-    maxOutputTokens: 16384,
     displayName: 'GPT-4.1 Nano',
   }],
   ['o3', {
     provider: 'openai',
     adapter: 'openai-responses',
     baseUrl: 'https://api.openai.com/v1',
-    contextWindow: 200000,
-    maxOutputTokens: 100000,
     displayName: 'o3',
     // task-327a: o-series reasoning models use reasoning.effort.
     supportsThinking: true,
@@ -155,8 +144,6 @@ export const MODEL_REGISTRY = new Map([
     provider: 'openai',
     adapter: 'openai-responses',
     baseUrl: 'https://api.openai.com/v1',
-    contextWindow: 200000,
-    maxOutputTokens: 100000,
     displayName: 'o4-mini',
     supportsThinking: true,
     thinkingProtocol: 'openai-reasoning',
@@ -168,16 +155,12 @@ export const MODEL_REGISTRY = new Map([
     provider: 'deepseek',
     adapter: 'openai-responses',
     baseUrl: 'https://api.deepseek.com',
-    contextWindow: 131072,
-    maxOutputTokens: 8192,
     displayName: 'DeepSeek Chat',
   }],
   ['deepseek-reasoner', {
     provider: 'deepseek',
     adapter: 'openai-responses',
     baseUrl: 'https://api.deepseek.com',
-    contextWindow: 131072,
-    maxOutputTokens: 8192,
     displayName: 'DeepSeek Reasoner',
   }],
 
@@ -186,16 +169,12 @@ export const MODEL_REGISTRY = new Map([
     provider: 'google',
     adapter: 'openai-responses',
     baseUrl: 'https://generativelanguage.googleapis.com/v1beta/openai',
-    contextWindow: 1048576,
-    maxOutputTokens: 65536,
     displayName: 'Gemini 2.5 Pro',
   }],
   ['gemini-2.5-flash', {
     provider: 'google',
     adapter: 'openai-responses',
     baseUrl: 'https://generativelanguage.googleapis.com/v1beta/openai',
-    contextWindow: 1048576,
-    maxOutputTokens: 65536,
     displayName: 'Gemini 2.5 Flash',
   }],
 ]);
@@ -214,9 +193,9 @@ export function resolveModel(modelName) {
 }
 
 /**
- * Default context window when neither the model registry nor the engine
- * config has a value. 200K is a conservative middle-ground — most modern
- * production models (Claude, GPT-5, Gemini) have ≥ 128K.
+ * Default context window when no upstream source has a value. 200K is a
+ * conservative middle-ground — most modern production models (Claude,
+ * GPT-5, Gemini) have ≥ 128K.
  *
  * Single source of truth: callers (engine.js pre-flight guard,
  * tools/registry.js per-result cap) MUST use this constant or
@@ -225,40 +204,106 @@ export function resolveModel(modelName) {
 export const DEFAULT_CONTEXT_WINDOW = 200_000;
 
 /**
- * Resolve the live context window for a model, with an explicit fallback
- * ladder:
- *   1. MODEL_REGISTRY entry's `contextWindow` (most accurate)
- *   2. caller-supplied config override (e.g. `config.maxContextTokens`)
- *   3. {@link DEFAULT_CONTEXT_WINDOW}
+ * Default per-call output cap when no upstream source has a value. This is
+ * the floor the adapters use to size `max_tokens`; production models give us
+ * more, but 16K is enough to make progress on any single turn without
+ * tripping a provider-side reject.
+ */
+export const DEFAULT_MAX_OUTPUT_TOKENS = 16_384;
+
+/**
+ * Resolve the live context window for a model.
+ *
+ * Fallback ladder (first match wins):
+ *   1. `config.modelInfo.contextWindow` — per-provider override originating
+ *      from `~/.yeaft/config.json: providers[].models[].contextWindow`. The
+ *      caller is responsible for passing the relevant entry; loadConfig
+ *      threads it through `config.modelInfo` already.
+ *   2. {@link lookupModelLimitSync} against the warmed models.dev snapshot,
+ *      hinted by the MODEL_REGISTRY provider when available so collisions
+ *      across providers resolve to the right entry.
+ *   3. `config.maxContextTokens` — global ceiling from config / CLI.
+ *   4. {@link DEFAULT_CONTEXT_WINDOW}.
  *
  * Used by the per-tool-result cap and the pre-flight token guard so the
  * defense layers always see the same number, regardless of which seam
  * resolves it first.
  *
  * @param {string} modelName
- * @param {{ maxContextTokens?: number }} [config]
+ * @param {{ maxContextTokens?: number, modelInfo?: { contextWindow?: number } } | null} [config]
  * @returns {number}
  */
 export function resolveContextWindow(modelName, config) {
-  const info = resolveModel(modelName);
-  if (info && Number.isFinite(info.contextWindow) && info.contextWindow > 0) {
-    return info.contextWindow;
+  // Rung 1: per-provider config override threaded via config.modelInfo.
+  const overrideCtx = config?.modelInfo?.contextWindow;
+  if (Number.isFinite(overrideCtx) && overrideCtx > 0) return overrideCtx;
+
+  // Rung 2: models.dev snapshot (warmed at agent boot).
+  const reg = MODEL_REGISTRY.get(modelName);
+  const limit = lookupModelLimitSync(modelName, reg?.provider || null);
+  if (limit && Number.isFinite(limit.context) && limit.context > 0) {
+    return limit.context;
   }
+
+  // Rung 3: global config ceiling.
   const cfg = config && Number.isFinite(config.maxContextTokens) && config.maxContextTokens > 0
     ? config.maxContextTokens : null;
   if (cfg !== null) return cfg;
+
+  // Rung 4: default.
   return DEFAULT_CONTEXT_WINDOW;
 }
 
 /**
- * List all known models.
+ * Resolve the live per-call output cap for a model. Same ladder as
+ * {@link resolveContextWindow} but for the `output` axis:
+ *   1. `config.modelInfo.maxOutput` override
+ *   2. models.dev `limit.output`
+ *   3. `config.maxOutputTokens`
+ *   4. {@link DEFAULT_MAX_OUTPUT_TOKENS}
+ *
+ * @param {string} modelName
+ * @param {{ maxOutputTokens?: number, modelInfo?: { maxOutput?: number, maxOutputTokens?: number } } | null} [config]
+ * @returns {number}
+ */
+export function resolveMaxOutputTokens(modelName, config) {
+  const overrideOut = config?.modelInfo?.maxOutput
+    ?? config?.modelInfo?.maxOutputTokens;
+  if (Number.isFinite(overrideOut) && overrideOut > 0) return overrideOut;
+
+  const reg = MODEL_REGISTRY.get(modelName);
+  const limit = lookupModelLimitSync(modelName, reg?.provider || null);
+  if (limit && Number.isFinite(limit.output) && limit.output > 0) {
+    return limit.output;
+  }
+
+  const cfg = config && Number.isFinite(config.maxOutputTokens) && config.maxOutputTokens > 0
+    ? config.maxOutputTokens : null;
+  if (cfg !== null) return cfg;
+
+  return DEFAULT_MAX_OUTPUT_TOKENS;
+}
+
+/**
+ * List all known models with their resolved token limits.
+ *
+ * Token limits are resolved at call time — they reflect whatever models.dev
+ * snapshot is currently warmed, plus the DEFAULT fallback for models the
+ * snapshot doesn't cover. The returned objects therefore mirror what
+ * `resolveContextWindow` / `resolveMaxOutputTokens` would return for the
+ * same model id.
  *
  * @returns {{ name: string, adapter: string, baseUrl: string, contextWindow: number, maxOutputTokens: number, displayName: string }[]}
  */
 export function listModels() {
   const result = [];
   for (const [name, info] of MODEL_REGISTRY) {
-    result.push({ name, ...info });
+    result.push({
+      name,
+      ...info,
+      contextWindow: resolveContextWindow(name, null),
+      maxOutputTokens: resolveMaxOutputTokens(name, null),
+    });
   }
   return result;
 }
@@ -484,11 +529,16 @@ export function serializeModelForPersistence(entry) {
  *
  * Lookup order:
  *   1. provider-config fields (contextWindow / maxOutput) — highest priority
- *   2. MODEL_REGISTRY entry (contextWindow / maxOutputTokens)
+ *   2. models.dev snapshot (`limit.{context,output}`) via the synchronous
+ *      reader, hinted by the MODEL_REGISTRY provider when known so cross-
+ *      provider id collisions resolve to the right entry.
  *   3. undefined if neither has any info
  *
  * Returns a normalized shape: `{ id, contextWindow?, maxOutput?, provider?, adapter?, baseUrl?, displayName? }`.
  *
+ * Note: token limits are intentionally NOT read from MODEL_REGISTRY — those
+ * fields were removed when models.dev became the source of truth.
+ *
  * @param {string} model
  * @param {{ id?: string, contextWindow?: number, maxOutput?: number } | null} [providerConfig]
  * @returns {object | undefined}
@@ -499,8 +549,12 @@ export function getModelInfo(model, providerConfig) {
   const overrideCtx = coercePositiveInt(providerConfig?.contextWindow);
   const overrideMax = coercePositiveInt(providerConfig?.maxOutput);
 
-  const ctx = overrideCtx ?? reg?.contextWindow;
-  const max = overrideMax ?? reg?.maxOutputTokens;
+  // Pull the models.dev numbers as the second rung. Hint with the registry's
+  // provider id when available — same alignment trick the resolveContext-
+  // Window ladder uses.
+  const limit = lookupModelLimitSync(model, reg?.provider || null);
+  const ctx = overrideCtx ?? (limit && Number.isFinite(limit.context) && limit.context > 0 ? limit.context : undefined);
+  const max = overrideMax ?? (limit && Number.isFinite(limit.output) && limit.output > 0 ? limit.output : undefined);
 
   // If we have literally no information, return undefined
   if (!reg && ctx === undefined && max === undefined) return undefined;