praxis-agent 0.62.0 → 0.62.2

package/README.md

@@ -98,6 +98,16 @@ cd /path/to/project
 praxis
 ```
 
+Anthropic models use a 200,000-token context window by default, including
+unknown model IDs. Add the exact terminal `[1m]` suffix (for example,
+`claude-sonnet-4-20250514[1m]`) to request a 1,000,000-token context window;
+Praxis keeps that selected model public, removes the suffix on the wire, and
+adds the `context-1m-2025-08-07` Anthropic beta once. An explicit
+`PRAXIS_CONTEXT_WINDOW_TOKENS` value overrides either inferred window.
+Exact `claude-sonnet-4-6` and `claude-opus-4-6` selections also support
+`--thinking adaptive`; use `--thinking enabled --max-thinking-tokens <n>`
+when a fixed thinking-token budget is required.
+
 Common non-interactive operations:
 
 ```sh
@@ -159,7 +169,9 @@ troubleshooting. Run `praxis --help` for the authoritative command surface.
   resize-safe lifecycle, Ctrl-C restoration, fullscreen `Ctrl+L` redraw, and
   mouse-wheel/drag selection with edge autoscroll and OSC 52 copy,
   interactive `/doctor` diagnostics, per-session model/effort/permission controls,
-  context/status/skill/task dashboards, prompt stash and continuation shortcuts,
+  context/status/skill/task dashboards whose context view previews the selected
+  provider/model capacity before the first turn and reports unavailable capacity
+  without fabricated percentages, prompt stash and continuation shortcuts,
   filterable `@` file and agent references, composer undo, `Ctrl+G` external
   editing, shared `/keybindings` creation/editing and supported-action remapping,
   shared built-in and custom `/theme` profiles with immediate
@@ -177,7 +189,7 @@ troubleshooting. Run `praxis --help` for the authoritative command surface.
   patches and readable binary/conflict/transient-path notes, semantic plan/question decision panels with complete
   screen-reader actions, semantic screen projection across selectable surfaces,
   deterministic resize-aware URL/form elicitation rendering, and measured
-  context budgets; print mode,
+  context budgets with base64-payload-independent image estimates; print mode,
   structured JSON/JSONL, context compaction, tool loops, and bounded execution.
 - **Built-in tools** — read, write, edit, `ApplyPatch` for bounded ordered exact
   multi-file replacements, configured plugin LSP navigation with fresh bounded
@@ -294,7 +306,9 @@ troubleshooting. Run `praxis --help` for the authoritative command surface.
   route, whether primary or fallback, stays sticky only through that logical
   Turn's tool continuations; incompatible routes fail closed, and the next
   independent Turn starts from primary. Recovery may persist only an optional
-  selected model, never provider route or wire state.
+  selected model, never provider route or wire state. Anthropic uses a
+  200,000-token default or exact terminal `[1m]` model syntax for 1,000,000
+  tokens; `PRAXIS_CONTEXT_WINDOW_TOKENS` overrides the advertised window.
 - **Transactional self-update** — `praxis update` verifies the package before
   installing it, rejects concurrent updates, and can roll back after an
   interruption or crash.

package/dist/cli/interactive.d.ts

@@ -85,6 +85,7 @@ interface InteractiveSessionCommands {
 }
 export interface InteractiveServiceFactory {
     scheduledPrompts?: boolean;
+    contextWindowTokens?(modelId?: string): number | undefined;
     createService(options: {
         eventSink: RuntimeEventSink;
         requireProvider: boolean;

package/dist/cli/interactive.js

@@ -471,7 +471,7 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
     const [, setTurnDuration] = useState();
     const [usage, setUsage] = useState();
     const [costUsd, setCostUsd] = useState();
-    const [contextWindowTokens, setContextWindowTokens] = useState(display.contextWindowTokens);
+    const [contextWindowTokens, setContextWindowTokens] = useState(display.contextWindowTokens ?? factory.contextWindowTokens?.());
     const [historyState, setHistoryState] = useState(() => {
         const items = [...initialHistory];
         return {
@@ -2237,8 +2237,7 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
             setAvailableSlashCommands(created.slashCommands?.() ?? slashCommands);
             setAvailableAgents(created.agentDefinitions?.() ?? agents);
             const runtimeInfo = created.runtimeInfo?.();
-            if (runtimeInfo?.contextWindowTokens !== undefined)
-                setContextWindowTokens(runtimeInfo.contextWindowTokens);
+            setContextWindowTokens(runtimeInfo?.contextWindowTokens);
             return created;
         }
         finally {
@@ -2314,6 +2313,7 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
         void loading.finally(() => onTurnChange?.(null));
     };
     const changeModel = (model) => {
+        setContextWindowTokens(factory.contextWindowTokens?.(model));
         updateRuntimePreferences((current) => {
             if (model !== undefined)
                 return { ...current, model };
@@ -6726,7 +6726,9 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
                 const contextEntry = {
                     kind: 'context',
                     usedTokens: Math.max(measuredTokens, skillTokens),
-                    contextWindowTokens: runtimeDisplay.contextWindowTokens ?? 200_000,
+                    ...(runtimeDisplay.contextWindowTokens === undefined
+                        ? {}
+                        : { contextWindowTokens: runtimeDisplay.contextWindowTokens }),
                     model: runtimeDisplay.model ?? 'provider default',
                     skills,
                     memoryFiles: [],

package/dist/cli/tui/claude-style.js

@@ -390,6 +390,15 @@ function percent(tokens, total) {
 }
 function ContextUsageBlock({ usedTokens, contextWindowTokens, model, skills, memoryFiles, screenReader, }) {
     const theme = useTuiTheme();
+    const resourceTree = (_jsxs(_Fragment, { children: [_jsx(Text, { children: " " }), _jsx(Text, { ...theme.text.heading, bold: true, children: "Memory files \u00B7 /memory" }), memoryFiles.length === 0 ? (_jsx(Text, { dimColor: true, children: "\u2514 No memory files" })) : (memoryFiles.map((file, index) => (_jsxs(Text, { dimColor: true, children: [index === memoryFiles.length - 1 ? '└' : '├', " ", file.path, ":", ' ', file.tokens, " tokens"] }, file.path)))), _jsx(Text, { children: " " }), _jsx(Text, { ...theme.text.heading, bold: true, children: "Skills \u00B7 /skills" }), _jsx(Text, { children: " " }), _jsx(Text, { children: "Loaded" }), skills.length === 0 ? (_jsx(Text, { dimColor: true, children: "\u2514 No skills loaded" })) : (skills.map((skill, index) => (_jsxs(Text, { dimColor: true, children: [index === skills.length - 1 ? '└' : '├', " ", skill.name, ": ~", skill.tokens, " tokens"] }, skill.name))))] }));
+    if (screenReader && contextWindowTokens === undefined) {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { ...theme.text.heading, children: "Context Usage" }), _jsxs(Text, { children: [model ?? 'provider default', " \u00B7 ", usedTokens.toLocaleString(), " tokens \u00B7 Context capacity unavailable"] }), _jsxs(Text, { children: ["Memory files:", ' ', memoryFiles
+                            .map((file) => `${file.path} (${file.tokens} tokens)`)
+                            .join(', ') || 'none'] }), _jsxs(Text, { children: ["Skills: ", skills.map(({ name }) => name).join(', ') || 'none'] })] }));
+    }
+    if (contextWindowTokens === undefined) {
+        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, marginLeft: 2, children: [_jsx(Text, { ...theme.text.heading, bold: true, children: "Context Usage" }), _jsxs(Text, { dimColor: true, children: [model ?? 'provider default', " \u00B7 ", usedTokens.toLocaleString(), " tokens \u00B7 Context capacity unavailable"] }), resourceTree] }));
+    }
     const totalTokens = Math.max(1, contextWindowTokens);
     const compactBuffer = Math.round(totalTokens * 0.165);
     const usable = Math.max(1, totalTokens - compactBuffer);
@@ -399,7 +408,7 @@ function ContextUsageBlock({ usedTokens, contextWindowTokens, model, skills, mem
     const usedCells = Math.min(25, Math.round((usedTokens / totalTokens) * 25));
     const bufferCells = Math.min(25 - usedCells, Math.round((compactBuffer / totalTokens) * 25));
     const cells = Array.from({ length: 25 }, (_, index) => index < usedCells ? '⛁' : index >= 25 - bufferCells ? '⛝' : '⛶');
-    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, marginLeft: 2, children: [_jsx(Text, { ...theme.text.heading, bold: true, children: "Context Usage" }), _jsxs(Box, { children: [_jsx(Box, { flexDirection: "column", marginRight: 2, children: Array.from({ length: 5 }, (_, row) => (_jsx(Text, { children: cells.slice(row * 5, row * 5 + 5).join(' ') }, row))) }), _jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: [model ?? 'provider default', " \u00B7 ", compactTokens(usedTokens), "/", compactTokens(totalTokens), " tokens (", percent(usedTokens, totalTokens), ")"] }), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, italic: true, children: "Estimated usage by category" }), _jsxs(Text, { children: ["\u26C1 Messages and other context: ", compactTokens(usedTokens), " tokens (", percent(usedTokens, totalTokens), ")"] }), _jsxs(Text, { children: ["\u26F6 Free space: ", compactTokens(Math.max(0, usable - usedTokens)), " (", percent(Math.max(0, usable - usedTokens), totalTokens), ")"] }), _jsxs(Text, { children: ["\u26DD Autocompact buffer: ", compactTokens(compactBuffer), " tokens (", percent(compactBuffer, totalTokens), ")"] })] })] }), _jsx(Text, { children: " " }), _jsx(Text, { ...theme.text.heading, bold: true, children: "Memory files \u00B7 /memory" }), memoryFiles.length === 0 ? (_jsx(Text, { dimColor: true, children: "\u2514 No memory files" })) : (memoryFiles.map((file, index) => (_jsxs(Text, { dimColor: true, children: [index === memoryFiles.length - 1 ? '└' : '├', " ", file.path, ":", ' ', file.tokens, " tokens"] }, file.path)))), _jsx(Text, { children: " " }), _jsx(Text, { ...theme.text.heading, bold: true, children: "Skills \u00B7 /skills" }), _jsx(Text, { children: " " }), _jsx(Text, { children: "Loaded" }), skills.length === 0 ? (_jsx(Text, { dimColor: true, children: "\u2514 No skills loaded" })) : (skills.map((skill, index) => (_jsxs(Text, { dimColor: true, children: [index === skills.length - 1 ? '└' : '├', " ", skill.name, ": ~", skill.tokens, " tokens"] }, skill.name))))] }));
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, marginLeft: 2, children: [_jsx(Text, { ...theme.text.heading, bold: true, children: "Context Usage" }), _jsxs(Box, { children: [_jsx(Box, { flexDirection: "column", marginRight: 2, children: Array.from({ length: 5 }, (_, row) => (_jsx(Text, { children: cells.slice(row * 5, row * 5 + 5).join(' ') }, row))) }), _jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: [model ?? 'provider default', " \u00B7 ", compactTokens(usedTokens), "/", compactTokens(totalTokens), " tokens (", percent(usedTokens, totalTokens), ")"] }), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, italic: true, children: "Estimated usage by category" }), _jsxs(Text, { children: ["\u26C1 Messages and other context: ", compactTokens(usedTokens), " tokens (", percent(usedTokens, totalTokens), ")"] }), _jsxs(Text, { children: ["\u26F6 Free space: ", compactTokens(Math.max(0, usable - usedTokens)), " (", percent(Math.max(0, usable - usedTokens), totalTokens), ")"] }), _jsxs(Text, { children: ["\u26DD Autocompact buffer: ", compactTokens(compactBuffer), " tokens (", percent(compactBuffer, totalTokens), ")"] })] })] }), resourceTree] }));
 }
 const MARKDOWN_TEXT_CACHE_MAX = 2048;
 const markdownTextCache = new Map();

package/dist/cli/tui/conversation-export.js

@@ -32,7 +32,9 @@ export function conversationExportText(_display, items) {
             output.push(...lines(item.text, '  ⎿ '));
         }
         else if (item.kind === 'context') {
-            output.push('', `Context Usage: ${item.usedTokens}/${item.contextWindowTokens} tokens`);
+            output.push('', item.contextWindowTokens === undefined
+                ? `Context Usage: ${item.usedTokens} tokens · Context capacity unavailable`
+                : `Context Usage: ${item.usedTokens}/${item.contextWindowTokens} tokens`);
         }
         else {
             output.push(...lines(item.text, item.kind === 'warning' ? '⚠ ' : '· '));

package/dist/cli/tui/transcript-presentation.d.ts

@@ -22,7 +22,7 @@ export type TranscriptItem = {
 } | {
     kind: 'context';
     usedTokens: number;
-    contextWindowTokens: number;
+    contextWindowTokens?: number;
     model?: string;
     skills: readonly {
         name: string;

package/dist/cli/tui/transcript-viewport.js

@@ -262,6 +262,21 @@ function percent(tokens, total) {
     return `${Math.round((tokens / Math.max(1, total)) * 100 * 10) / 10}%`;
 }
 function contextUsageLineCount(item, width) {
+    if (item.contextWindowTokens === undefined) {
+        const resourceWidth = Math.max(1, width - 2);
+        const memoryRows = item.memoryFiles.length
+            ? item.memoryFiles.reduce((rows, file, index) => rows +
+                wrappedLineCount(`${index === item.memoryFiles.length - 1 ? '└' : '├'} ${file.path}: ${file.tokens} tokens`, resourceWidth), 0)
+            : wrappedLineCount('└ No memory files', resourceWidth);
+        const skillRows = item.skills.length
+            ? item.skills.reduce((rows, skill, index) => rows +
+                wrappedLineCount(`${index === item.skills.length - 1 ? '└' : '├'} ${skill.name}: ~${skill.tokens} tokens`, resourceWidth), 0)
+            : wrappedLineCount('└ No skills loaded', resourceWidth);
+        return (8 +
+            wrappedLineCount(`${item.model ?? 'provider default'} · ${item.usedTokens.toLocaleString()} tokens · Context capacity unavailable`, resourceWidth) +
+            memoryRows +
+            skillRows);
+    }
     const totalTokens = Math.max(1, item.contextWindowTokens);
     const compactBuffer = Math.round(totalTokens * 0.165);
     const usable = Math.max(1, totalTokens - compactBuffer);
@@ -367,6 +382,14 @@ function visibleOutputLineCount(text, width, mode) {
             : 0));
 }
 function screenReaderContextLineCount(item, width) {
+    if (item.contextWindowTokens === undefined) {
+        return [
+            'Context Usage',
+            `${item.model ?? 'provider default'} · ${item.usedTokens.toLocaleString()} tokens · Context capacity unavailable`,
+            `Memory files: ${item.memoryFiles.map((file) => `${file.path} (${file.tokens} tokens)`).join(', ') || 'none'}`,
+            `Skills: ${item.skills.map(({ name }) => name).join(', ') || 'none'}`,
+        ].reduce((rows, line) => rows + wrappedLineCount(line, width), 0);
+    }
     const totalTokens = Math.max(1, item.contextWindowTokens);
     const compactBuffer = Math.round(totalTokens * 0.165);
     return [

package/dist/cli/tui/tui-row-ir.js

@@ -38,7 +38,9 @@ function entryText(entry) {
             };
         if (item.kind === 'context')
             return {
-                text: `Context Usage · ${item.usedTokens}/${item.contextWindowTokens} tokens`,
+                text: item.contextWindowTokens === undefined
+                    ? `Context Usage · ${item.usedTokens} tokens · Context capacity unavailable`
+                    : `Context Usage · ${item.usedTokens}/${item.contextWindowTokens} tokens`,
                 role: 'heading',
             };
     }

package/dist/cli-runtime.d.ts

@@ -232,6 +232,7 @@ export declare function resolveInteractiveProviderStartup(options: {
 }): Promise<{
     effectiveModel: string | undefined;
     trustProjectRequestAvailable: boolean;
+    contextWindowTokensForModel: (modelId?: string) => number | undefined;
 }>;
 export declare function createDefaultDependencies(entrypoint?: string): CliDependencies;
 export declare function createBackgroundWorkerRuntime(workerSink: RuntimeEventSink, dispatch: {

package/dist/cli-runtime.js

@@ -51,7 +51,7 @@ import { FallbackModelProvider } from './providers/fallback-provider.js';
 import { ProviderCredentialVault } from './persistence/provider-credential-vault.js';
 import { parseContextEnvironment, parseProviderEnvironment, } from './providers/environment.js';
 import { ProviderAuthenticationError, resolveProviderCredential, } from './providers/provider-auth.js';
-import { resolveProviderRegistry } from './providers/provider-registry.js';
+import { resolveProviderContextWindowTokens, resolveProviderRegistry, } from './providers/provider-registry.js';
 import { ProviderSettingsError, resolveProviderTarget, } from './providers/provider-settings.js';
 import { ModelPricingRegistry, usageCostUsd } from './core/usage.js';
 import { LocalToolRegistry } from './tools/local-tools.js';
@@ -2482,8 +2482,9 @@ export async function resolveInteractiveProviderStartup(options) {
         truthyEnvironmentValue(environment.CLAUDE_CODE_SIMPLE);
     if (disabled) {
         let effectiveModel;
+        let protocol;
         try {
-            effectiveModel = (await resolveProviderTarget({
+            const target = await resolveProviderTarget({
                 configRoot: options.configRoot,
                 cwd: options.cwd,
                 environment,
@@ -2497,16 +2498,28 @@ export async function resolveInteractiveProviderStartup(options) {
                     ? {}
                     : { profile: options.controls.providerProfile }),
                 includeSettings: false,
-            })).modelId;
+            });
+            effectiveModel = target.modelId;
+            protocol = target.protocol;
         }
         catch (error) {
             if (!(error instanceof ProviderSettingsError &&
                 error.code === 'model_required'))
                 throw error;
         }
+        const context = parseContextEnvironment(environment);
         return {
             effectiveModel,
             trustProjectRequestAvailable: options.controls.trustProject,
+            contextWindowTokensForModel: (modelId) => protocol === undefined
+                ? undefined
+                : resolveProviderContextWindowTokens({
+                    protocol,
+                    modelId: modelId ?? effectiveModel ?? '',
+                    ...(context.contextWindowTokens === undefined
+                        ? {}
+                        : { explicitContextWindowTokens: context.contextWindowTokens }),
+                }),
         };
     }
     const assessment = await assessCurrentWorkspaceProviderSelection({
@@ -2531,8 +2544,9 @@ export async function resolveInteractiveProviderStartup(options) {
         }
     }
     let effectiveModel;
+    let protocol;
     try {
-        effectiveModel = (await resolveProviderTarget({
+        const target = await resolveProviderTarget({
             configRoot: options.configRoot,
             cwd: options.cwd,
             environment,
@@ -2547,13 +2561,28 @@ export async function resolveInteractiveProviderStartup(options) {
                 : { profile: options.controls.providerProfile }),
             includeSettings: true,
             includeProjectSettings,
-        })).modelId;
+        });
+        effectiveModel = target.modelId;
+        protocol = target.protocol;
     }
     catch (error) {
         if (!(error instanceof ProviderSettingsError && error.code === 'model_required'))
             throw error;
     }
-    return { effectiveModel, trustProjectRequestAvailable };
+    const context = parseContextEnvironment(environment);
+    return {
+        effectiveModel,
+        trustProjectRequestAvailable,
+        contextWindowTokensForModel: (modelId) => protocol === undefined
+            ? undefined
+            : resolveProviderContextWindowTokens({
+                protocol,
+                modelId: modelId ?? effectiveModel ?? '',
+                ...(context.contextWindowTokens === undefined
+                    ? {}
+                    : { explicitContextWindowTokens: context.contextWindowTokens }),
+            }),
+    };
 }
 export function createDefaultDependencies(entrypoint = fileURLToPath(import.meta.url)) {
     const dependencies = {
@@ -2629,6 +2658,7 @@ export function createDefaultDependencies(entrypoint = fileURLToPath(import.meta
                 statePath: interactiveStatePath,
                 factory: {
                     createService: createInteractiveService,
+                    contextWindowTokens: startup.contextWindowTokensForModel,
                     scheduledPrompts: Boolean(effectiveModel),
                 },
                 ...(signal ? { signal } : {}),

package/dist/core/context-budget.js

@@ -24,6 +24,12 @@ export function estimateTextTokens(value) {
     }
     return Math.ceil(ascii / 4) + nonAscii;
 }
+const IMAGE_VISUAL_TOKEN_ESTIMATE = 1_600;
+// This provider-neutral conservative fallback never interprets billed usage;
+// observed provider usage remains authoritative at a ContextBudget watermark.
+function estimateImageTokens(mediaType) {
+    return 8 + estimateTextTokens(mediaType) + IMAGE_VISUAL_TOKEN_ESTIMATE;
+}
 function estimateMessageTokens(message) {
     let tokens = 4 + estimateTextTokens(message.role);
     if (message.role === 'tool') {
@@ -31,16 +37,14 @@ function estimateMessageTokens(message) {
             estimateTextTokens(message.toolCallId) +
                 estimateTextTokens(message.content);
         for (const image of message.images ?? []) {
-            tokens +=
-                8 + estimateTextTokens(image.mediaType) + estimateTextTokens(image.data);
+            tokens += estimateImageTokens(image.mediaType);
         }
         return tokens + (message.isError ? 1 : 0);
     }
     tokens += estimateTextTokens(message.content);
     if (message.role === 'user') {
         for (const image of message.images ?? []) {
-            tokens +=
-                8 + estimateTextTokens(image.mediaType) + estimateTextTokens(image.data);
+            tokens += estimateImageTokens(image.mediaType);
         }
         for (const document of message.documents ?? []) {
             tokens += 8 + estimateTextTokens(document.mediaType) + 2000;

package/dist/providers/anthropic-compatible.d.ts

@@ -4,6 +4,10 @@ export interface AnthropicCompatibleProviderOptions {
     baseUrl: string;
     apiKey: string;
     model: string;
+    promptCacheResolver?: (target: {
+        baseUrl: string;
+        model: string;
+    }) => AnthropicPromptCachePolicy;
     maxOutputTokens?: number;
     anthropicVersion?: string;
     webSearch?: boolean;
@@ -32,6 +36,9 @@ export declare class AnthropicCompatibleProvider implements ModelProvider {
     private readonly maxToolMetadataBytes;
     private readonly maxErrorBodyBytes;
     private readonly thinking;
+    private readonly wireModel;
+    private readonly supportsAdaptiveThinking;
+    private readonly providerBetas;
     private readonly promptCaching;
     private readonly streaming;
     constructor(options: AnthropicCompatibleProviderOptions);

package/dist/providers/anthropic-compatible.js

@@ -3,6 +3,7 @@ import { transportFailureKind } from './provider-errors.js';
 import { reportProviderTransportActivity } from './provider-transport-activity.js';
 import { markNonStreamingFallbackEligible } from './non-streaming-fallback-provider.js';
 import { createAnthropicPromptCachePolicyResolver, } from './anthropic-prompt-cache.js';
+import { resolveAnthropicModelSpec } from './anthropic-model-spec.js';
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -49,17 +50,23 @@ function positiveInteger(value, label) {
     }
     return value;
 }
-function validateThinking(thinking) {
+function validateThinking(thinking, supportsAdaptiveThinking) {
     if (!thinking)
         return undefined;
     if (!['enabled', 'adaptive', 'disabled'].includes(thinking.mode)) {
         throw new Error(`Unsupported thinking mode: ${thinking.mode}`);
     }
+    if (thinking.mode === 'adaptive' && !supportsAdaptiveThinking) {
+        throw new Error('Adaptive thinking is only supported for explicit Claude Sonnet 4.6 or Opus 4.6 models');
+    }
     if (thinking.maxTokens !== undefined) {
         positiveInteger(thinking.maxTokens, 'Max thinking tokens');
         if (thinking.mode === 'disabled') {
             throw new Error('Max thinking tokens cannot be used when thinking is disabled');
         }
+        if (thinking.mode === 'adaptive') {
+            throw new Error('Max thinking tokens cannot be used with adaptive thinking; use enabled thinking for a fixed budget');
+        }
     }
     return thinking;
 }
@@ -643,21 +650,26 @@ export class AnthropicCompatibleProvider {
     maxToolMetadataBytes;
     maxErrorBodyBytes;
     thinking;
+    wireModel;
+    supportsAdaptiveThinking;
+    providerBetas;
     promptCaching;
     streaming;
     constructor(options) {
         this.options = options;
-        if (options.contextWindowTokens !== undefined) {
-            positiveInteger(options.contextWindowTokens, 'Context window tokens');
-        }
+        const modelSpec = resolveAnthropicModelSpec(options.model, options.contextWindowTokens);
+        positiveInteger(modelSpec.contextWindowTokens, 'Context window tokens');
         this.endpoint = `${options.baseUrl.replace(/\/+$/, '')}/messages`;
-        this.model = options.model;
+        this.model = modelSpec.model;
+        this.wireModel = modelSpec.wireModel;
+        this.supportsAdaptiveThinking = modelSpec.supportsAdaptiveThinking;
+        this.providerBetas = Object.freeze([...modelSpec.betas]);
         this.streaming = options.streaming ?? true;
         this.fetchImplementation = options.fetchImplementation ?? fetch;
         this.maxOutputTokens = positiveInteger(options.maxOutputTokens ??
-            (options.model.includes('claude-opus-4-6')
+            (this.wireModel.includes('claude-opus-4-6')
                 ? 64_000
-                : options.model.startsWith('claude-')
+                : this.wireModel.startsWith('claude-')
                     ? 32_000
                     : 8192), 'Max output tokens');
         this.capabilities = {
@@ -668,22 +680,25 @@ export class AnthropicCompatibleProvider {
             documents: true,
             webSearch: options.webSearch === true,
             thinking: {
-                modes: ['enabled', 'adaptive', 'disabled'],
+                modes: modelSpec.supportsAdaptiveThinking
+                    ? ['enabled', 'adaptive', 'disabled']
+                    : ['enabled', 'disabled'],
                 maxTokens: true,
             },
-            ...(options.contextWindowTokens === undefined
-                ? {}
-                : { contextWindowTokens: options.contextWindowTokens }),
+            contextWindowTokens: modelSpec.contextWindowTokens,
             maxOutputTokens: this.maxOutputTokens,
             terminalReasons: true,
         };
-        this.thinking = validateThinking(options.thinking);
-        const promptCaching = options.promptCaching === false
-            ? undefined
-            : (options.promptCaching ??
+        this.thinking = validateThinking(options.thinking, this.supportsAdaptiveThinking);
+        const promptCaching = options.promptCaching !== undefined
+            ? options.promptCaching
+            : (options.promptCacheResolver?.({
+                baseUrl: options.baseUrl,
+                model: this.wireModel,
+            }) ??
                 createAnthropicPromptCachePolicyResolver({}, 'native')({
                     baseUrl: options.baseUrl,
-                    model: options.model,
+                    model: this.wireModel,
                 }));
         this.promptCaching = promptCaching
             ? cacheControl(promptCaching.ttl)
@@ -703,17 +718,20 @@ export class AnthropicCompatibleProvider {
         if (request.webSearch && request.tools?.length) {
             throw new Error('Web search cannot be combined with model tools');
         }
-        const thinking = validateThinking(request.thinking ?? this.thinking);
+        const thinking = validateThinking(request.thinking ?? this.thinking, this.supportsAdaptiveThinking);
         const maxTokens = Math.max(this.maxOutputTokens, thinking?.maxTokens === undefined ? 0 : thinking.maxTokens + 1);
         const thinkingPayload = thinking === undefined
             ? undefined
             : thinking.mode === 'disabled'
                 ? { type: 'disabled' }
-                : {
-                    type: 'enabled',
-                    budget_tokens: thinking.maxTokens ?? maxTokens - 1,
-                };
+                : thinking.mode === 'adaptive'
+                    ? { type: 'adaptive' }
+                    : {
+                        type: 'enabled',
+                        budget_tokens: thinking.maxTokens ?? maxTokens - 1,
+                    };
         const betas = [
+            ...this.providerBetas,
             ...(request.betas ?? []),
             ...(thinking && thinking.mode !== 'disabled'
                 ? ['interleaved-thinking-2025-05-14']
@@ -730,7 +748,7 @@ export class AnthropicCompatibleProvider {
                 ...(betas.length ? { 'anthropic-beta': betas.join(',') } : {}),
             },
             body: JSON.stringify({
-                model: this.options.model,
+                model: this.wireModel,
                 max_tokens: maxTokens,
                 messages: serialized.messages,
                 stream: this.streaming,

package/dist/providers/anthropic-model-spec.d.ts

@@ -0,0 +1,10 @@
+export declare const ANTHROPIC_LONG_CONTEXT_BETA = "context-1m-2025-08-07";
+export interface ResolvedAnthropicModelSpec {
+    readonly model: string;
+    readonly wireModel: string;
+    readonly contextWindowTokens: number;
+    readonly betas: readonly string[];
+    readonly supportsAdaptiveThinking: boolean;
+}
+export declare function resolveAnthropicModelSpec(model: string, explicitContextWindowTokens?: number): ResolvedAnthropicModelSpec;
+//# sourceMappingURL=anthropic-model-spec.d.ts.map

package/dist/providers/anthropic-model-spec.js

@@ -0,0 +1,16 @@
+export const ANTHROPIC_LONG_CONTEXT_BETA = 'context-1m-2025-08-07';
+export function resolveAnthropicModelSpec(model, explicitContextWindowTokens) {
+    const longContext = model.endsWith('[1m]');
+    const wireModel = longContext ? model.slice(0, -'[1m]'.length) : model;
+    if (longContext && wireModel.trim().length === 0) {
+        throw new Error('Anthropic [1m] model spec must include a base model name');
+    }
+    return Object.freeze({
+        model,
+        wireModel,
+        contextWindowTokens: explicitContextWindowTokens ?? (longContext ? 1_000_000 : 200_000),
+        betas: Object.freeze(longContext ? [ANTHROPIC_LONG_CONTEXT_BETA] : []),
+        supportsAdaptiveThinking: wireModel === 'claude-sonnet-4-6' || wireModel === 'claude-opus-4-6',
+    });
+}
+//# sourceMappingURL=anthropic-model-spec.js.map

package/dist/providers/provider-registry.d.ts

@@ -1,6 +1,6 @@
 import type { ModelProvider, ModelThinkingConfig } from '../core/runtime.js';
 import { type CodexOAuthVault } from './codex-oauth.js';
-import { type ProviderTarget } from './provider-settings.js';
+import { type ProviderProtocol, type ProviderTarget } from './provider-settings.js';
 import type { ProviderCredentialSourceMetadata, ProviderCredentialReader, ResolvedProviderCredential } from './provider-auth.js';
 import { parseProviderEnvironment, type ContextEnvironment } from './environment.js';
 import { type AnthropicPromptCachePolicy } from './anthropic-prompt-cache.js';
@@ -47,6 +47,11 @@ export interface ProviderRegistry {
     readonly credentialSource: ProviderRegistrySourceMetadata;
     create(modelId?: string): ModelProvider;
 }
+export declare function resolveProviderContextWindowTokens(options: {
+    protocol: ProviderProtocol;
+    modelId: string;
+    explicitContextWindowTokens?: number;
+}): number | undefined;
 export declare function resolveProviderRegistry(options: ResolveProviderRegistryOptions): Promise<ProviderRegistry>;
 export declare function createProviderRegistry(options: ProviderRegistryOptions): ProviderRegistry;
 //# sourceMappingURL=provider-registry.d.ts.map

package/dist/providers/provider-registry.js

@@ -6,6 +6,7 @@ import { DeadlineModelProvider } from './deadline-provider.js';
 import { NonStreamingFallbackModelProvider } from './non-streaming-fallback-provider.js';
 import { CodexOAuthCredentialManager, } from './codex-oauth.js';
 import { resolveProviderTarget, } from './provider-settings.js';
+import { resolveAnthropicModelSpec } from './anthropic-model-spec.js';
 import { ProviderAuthenticationError, resolveProviderCredential, } from './provider-auth.js';
 import { parseContextEnvironment, parseProviderEnvironment, } from './environment.js';
 import { createAnthropicPromptCachePolicyResolver, } from './anthropic-prompt-cache.js';
@@ -17,6 +18,14 @@ export class ProviderRegistryError extends Error {
         this.code = code;
     }
 }
+export function resolveProviderContextWindowTokens(options) {
+    if (options.protocol === 'anthropic-messages')
+        return resolveAnthropicModelSpec(options.modelId, options.explicitContextWindowTokens).contextWindowTokens;
+    if (options.protocol === 'openai-compatible' ||
+        options.protocol === 'openai-responses')
+        return options.explicitContextWindowTokens;
+    return undefined;
+}
 export async function resolveProviderRegistry(options) {
     const environment = options.environment ?? process.env;
     const target = await resolveProviderTarget({
@@ -175,10 +184,7 @@ class NativeProviderRegistry {
                 ...(this.options.anthropicPromptCacheResolver === undefined
                     ? {}
                     : {
-                        promptCaching: this.options.anthropicPromptCacheResolver({
-                            baseUrl: target.baseUrl,
-                            model: target.modelId,
-                        }),
+                        promptCacheResolver: this.options.anthropicPromptCacheResolver,
                     }),
                 ...(this.options.providerEnvironment?.maxOutputTokens === undefined
                     ? {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "praxis-agent",
-  "version": "0.62.0",
+  "version": "0.62.2",
   "description": "Local-first, single-user general agent for the command line.",
   "license": "MIT",
   "author": "wuqisen",