Model profiles

resolveModelProfile(model) returns one explainable record for a model descriptor: what the SDK knows about the model (capabilities, lifecycle status, limits, and where those facts come from) and the request rules it applies when it calls the model (where effort goes, what effort: 'none' becomes, what happens to temperature and forced tool choice, and every value a request changes on the way).

A profile is a pure read. Resolving one never calls the provider, never logs, and never contains your API key or base URL, so it runs offline, in a browser or on an edge runtime.

Resolve a profile

import { resolveModelProfile } from '@deuz-sdk/core';
import { createAnthropic } from '@deuz-sdk/core/anthropic';

const anthropic = createAnthropic({ apiKey: process.env.ANTHROPIC_API_KEY! });
const profile = resolveModelProfile(anthropic('claude-opus-5-5'));

profile.status; // 'stable'
profile.capabilities.vision; // 'supported'
profile.capabilities.audio; // 'unknown' (the source does not say)
profile.effort; // { field: 'output_config.effort', levels: ['low', …, 'max'], default: 'medium', none: 'lowest' }
profile.limits; // { contextWindow: 1_000_000, maxOutput: 128_000, defaultOutputCap: 128_000 }
profile.liveVerified; // false

The result is a frozen copy, rebuilt on every call. Unknown model ids never throw. They get a profile whose facts are 'unknown'.

What a profile contains

Prices are not part of a profile. They stay in the price table; see Pricing & budgets.

Supported, unsupported, unknown

The capability matrix the adapters read (getModelCapabilities) holds booleans, and an unknown model gets conservative defaults such as tools: false. A profile does not repeat those defaults as facts. A capability is reported as supported or unsupported only when:

• a pinned registry row states it and the documented source does not leave it open, or
• you claimed it through a factory capabilities override.

Everything else is 'unknown'. For example, DeepSeek V4 rejects response_format: json_schema, so its structuredOutput is 'unsupported', while the newer deepseek-flash row keeps the same safe default without a source to back it, so its profile says 'unknown'. The same holds for a pinned row whose limits are undocumented, such as the GPT-5.6 rows: their context window, vision and the other values no source states are 'unknown', not the row's conservative defaults.

import { resolveModelProfile } from '@deuz-sdk/core';
import { createOllama } from '@deuz-sdk/core/providers';

// A model you pulled yourself has no registry row: everything is unknown...
const local = createOllama()('my-finetune:latest');
resolveModelProfile(local).capabilities.tools; // 'unknown'

// ...until you say what you know, once, on the factory.
const told = createOllama({ capabilities: { tools: true, maxOutput: 32_000 } });
const profile = resolveModelProfile(told('my-finetune:latest'));
profile.capabilities.tools; // 'supported'
profile.limits; // { maxOutput: 32_000, defaultOutputCap: 32_000 }

Effort, and what 'none' becomes

effort.levels lists the levels that reach the wire unchanged. A level the model lacks is lowered to the nearest accepted level below it (or raised to the lowest one) and reported as a clamped-setting warning. effort.none says what effort: 'none' becomes:

Anthropic turns thinking off only at effort high or below. A model whose documented default effort is within that limit keeps it. One that documents no default, such as claude-opus-5, also gets output_config.effort: 'low', and the call reports that as a clamped-setting warning.

The current models:

The earlier GPT-5 snapshots take the effort levels OpenAI publishes for each one. These sets are research-dated (2026-10-10) and not live-verified:

The GPT-5.6 rows and the gpt-5.2-pro, gpt-5.4-pro and gpt-5.2-codex snapshots have no pinned set. Like gpt-6-astra, they keep the OpenAI wire's historical mapping: low … xhigh, with 'none' sent as 'none'.

Three output limits

A profile keeps three numbers apart:

• limits.contextWindow: the model's total context window.
• limits.maxOutput: the most the provider lets the model write.
• limits.defaultOutputCap: what a request carries when you pass no maxOutputTokens.

They differ on purpose. DeepSeek V4 accepts up to 65,536 output tokens, but its default request cap stays at 8,192 so one runaway thinking pass does not turn into a large bill.

When a limit is undocumented, the SDK does not guess one onto the wire. On OpenAI Chat Completions, OpenAI Responses and Gemini native, where the output cap is optional, defaultOutputCap is 'omitted' and the provider's own default applies. Earlier releases sent a 4,096-token placeholder there, which silently truncated long answers. Anthropic's max_tokens is required, so an unknown Claude id still sends 4,096. The unknown-model warning says so and names the two ways to raise it: maxOutputTokens per call, or capabilities: { maxOutput }. A native call under a token or USD budget is the exception: it sends the placeholder, so its reservation bounds what it can bill.

Clamps: no value changes in silence

profile.clamps lists every value a request changes on the way to the wire and the typed CallWarning the call reports for it. Read it before a call to warn a user up front:

import { resolveModelProfile } from '@deuz-sdk/core';
import { createAnthropic } from '@deuz-sdk/core/anthropic';

const anthropic = createAnthropic({ apiKey: process.env.ANTHROPIC_API_KEY! });

for (const clamp of resolveModelProfile(anthropic('claude-opus-5-5')).clamps) {
  console.log(`${clamp.setting}: ${clamp.from} → ${clamp.to} (${clamp.warning})`);
}
// effort: none → low (clamped-setting)
// temperature: * → dropped (unsupported-setting)
// topP: * → dropped (unsupported-setting)
// toolChoice: 'required' → auto (clamped-setting)
// toolChoice: { type: 'tool' } → auto (clamped-setting)
// mode: 'tool' → json (clamped-setting)

The same changes arrive at run time as warnings on the result and as warning parts on fullStream, logged once per run. The clamps a request can report:

• Effort levels. OpenAI 'max' becomes 'xhigh' unless the model lists 'max' (as gpt-6.1-sol does). Gemini 3 'xhigh' and 'max' become 'high', and Gemini 3 Pro 'medium' becomes 'low'. On the two budget wires (Anthropic thinking.budget_tokens, Gemini 2.5 thinkingBudget), 'xhigh' and 'max' send the same budget.
• Effort 'none' on a model that cannot turn reasoning off, and on an Anthropic model that turns thinking off but documents no default effort of high or below, where output_config.effort is pinned to 'low'.
• Sampling. temperature and topP are dropped for a model that rejects them, and on the Anthropic budget wire while extended thinking is on.
• Forced tool choice. 'required' or a named tool becomes 'auto' for a model that rejects forcing.
• Structured-output mode. An explicit mode: 'tool' in generateObject or streamObject runs the json strategy when the model cannot be forced into a tool, or Anthropic thinking is on for the request.
• maxOutputTokens is raised when an Anthropic thinking budget needs room for the answer.
• promptCaching is dropped for an Anthropic model without the caching capability.

Claude 5.x request rules

These rules are verified against Anthropic's API reference (cached 2026-10-06) and are not live-verified. For claude-fable-5-1, claude-opus-5-5, claude-sonnet-5-5 and claude-haiku-5-5:

• Effort rides output_config.effort. thinking.budget_tokens is never sent.
• temperature, top_p and top_k are never sent. Fable 5.1 and Opus 5.5 reject every value. Sonnet 5.5 and Haiku 5.5 accept only the defaults, and Haiku 5.5 never accepts both together.
• Structured output uses output_config.format. generateObject and streamObject never take the forced-tool strategy on these models.
• A forced toolChoice is sent as 'auto' on Fable 5.1, Opus 5.5 and Sonnet 5.5. Haiku 5.5 accepts it, but skips thinking for that turn.
• Prompt caching, vision, a 1,000,000-token context window and 128,000 output tokens.
• Any unknown claude-fable-N, claude-opus-N, claude-sonnet-N or claude-haiku-N with N ≥ 5 (for example claude-opus-9-9) gets the strictest of these rules instead of the generic fallback. A capabilities override cannot put budget_tokens or sampling parameters back on the wire for this family.

OpenAI Responses is stateless by default

Every Responses request carries store: false. A reasoning model always asks for reasoning.encrypted_content, with or without tools, and the SDK replays that encrypted reasoning on the next turn. Conversations keep their reasoning state without server-side storage, and organisations with zero data retention keep working. To opt back in to server-side storage:

import { generateText } from '@deuz-sdk/core';
import { createOpenAIResponses } from '@deuz-sdk/core/openai';

const openai = createOpenAIResponses({ apiKey: process.env.OPENAI_API_KEY! });

await generateText({
  model: openai('gpt-6.1-sol'),
  prompt: 'Summarise the release notes.',
  providerOptions: { openai: { store: true } },
});

OpenAI's retention behaviour itself is not live-verified.

Endpoints are never guessed from a model id

• Z.ai GLM. Access to glm-5.3 depends on the account and its Coding Plan history. createGLM defaults to BigModel (open.bigmodel.cn). Pass baseURL for Z.ai's international API:

  import { createGLM } from '@deuz-sdk/core/providers';
  
  const glm = createGLM({
    apiKey: process.env.ZAI_API_KEY!,
    baseURL: 'https://api.z.ai/api/paas/v4',
  });
  const model = glm('glm-5.3');

• Open weights. Qwen/Qwen3-Coder-Next has one profile for every host that serves it: Ollama, LM Studio, or vLLM and SGLang through createOpenAICompatible with a baseURL. Tool calling depends on the engine's qwen3_coder tool parser, so its profile reports tools as 'unknown'.

Current model support

What 2.3 knows about each tracked model. Everything here is pinned in the registry and is not live-verified. The support matrix says how far each row is verified and which offline tests cover it.

Related

• Model registry & capabilities: the capability matrix and its capabilities override.
• Pricing & budgets: prices, cache rates and long-context tiers.
• streamChat warnings: how CallWarnings reach your code.