maka-agent 0.2.1-dev.85.20261014 → 0.2.1-dev.87.20261015

package/dist/acp/session-configuration.js

@@ -28,6 +28,7 @@ const PERMISSION_NAMES = {
 const THINKING_NAMES = {
     default: 'Default',
     off: 'Off',
+    on: 'On',
     minimal: 'Minimal',
     low: 'Low',
     medium: 'Medium',

package/dist/run-command-core.js

@@ -117,14 +117,13 @@ export function parseMakaRunArgs(argv) {
             ...(flags.get('cwd') !== undefined ? { cwd: flags.get('cwd') } : {}),
             ...(flags.get('connection') !== undefined ? { connection: flags.get('connection') } : {}),
             ...(flags.get('model') !== undefined ? { model: flags.get('model') } : {}),
-            ...(thinking !== undefined && thinking !== 'default' ? { thinking } : {}),
+            ...(thinking !== undefined ? { thinking: thinking === 'default' ? null : thinking } : {}),
             ...(timeoutSeconds !== undefined ? { timeoutMs: Math.ceil(timeoutSeconds * 1_000) } : {}),
             ...(parsedMaxSteps !== undefined ? { maxSteps: parsedMaxSteps } : {}),
             ...(booleanFlags.has('yolo') ? { yolo: true } : {}),
             ...(resumeId !== undefined ? { resumeId } : {}),
             ...(continueLatest ? { continueLatest: true } : {}),
             ...(graph ? { graph: true } : {}),
-            ...(thinking === 'default' ? { thinkingDefaultExplicit: true } : {}),
             ...(flags.get('host') !== undefined ? { hostProfileId: flags.get('host') } : {}),
             ...(flags.get('project') !== undefined ? { projectId: flags.get('project') } : {}),
         },
@@ -159,10 +158,8 @@ export async function runMakaTextCliCore(argv, adapter, overrides = {}) {
                 ? { explicitConnection: parsed.options.connection }
                 : {}),
             ...(parsed.options.model !== undefined ? { explicitModel: parsed.options.model } : {}),
-            thinkingSpecified: parsed.options.thinking !== undefined || parsed.options.thinkingDefaultExplicit === true,
-            ...(parsed.options.thinking !== undefined
-                ? { explicitThinking: parsed.options.thinking }
-                : {}),
+            thinkingSpecified: parsed.options.thinking !== undefined,
+            ...(parsed.options.thinking != null ? { explicitThinking: parsed.options.thinking } : {}),
         }, {
             canonicalizeDirectory: canonicalDirectory,
             ...(parsed.options.hostProfileId && parsed.options.hostProfileId !== 'local'
@@ -381,7 +378,7 @@ function makaRunHelpText(cliCommand) {
         '  --host <profile-id>       Connect through a saved Runtime Host profile',
         '  --project <project-id>    Select an existing Project on a remote Host',
         '  --model <id>              Model to use',
-        '  --thinking <level>        off|minimal|low|medium|high|xhigh|max|default',
+        '  --thinking <level>        off|on|minimal|low|medium|high|xhigh|max|default',
         '  --timeout <seconds>       Invocation timeout',
         '  --max-steps <count>       Tool-step cap',
         '  --yolo                    Give this task full access to your files and network',

package/dist/runtime-host-session-driver.js

@@ -159,12 +159,12 @@ class RuntimeHostMakaSessionDriverImpl {
             this.#llmConnectionId = input.llmConnectionId;
         this.#llmConnectionSlug = input.llmConnectionSlug;
         this.#model = input.model;
-        this.#thinkingLevel = input.thinkingLevel;
+        this.#thinkingLevel = input.thinkingLevel ?? undefined;
         // An omitted mode stays omitted: the Host applies its configured default.
         // Substituting a literal `ask` here would make the CLI a second authority
         // over the starting boundary and silently override that default.
         this.#permissionMode = input.permissionMode;
-        const session = await this.#createSession(input.name ?? DEFAULT_SESSION_NAME);
+        const session = await this.#createSession(input.name ?? DEFAULT_SESSION_NAME, input.thinkingLevel);
         return projectSessionCatalogSummary(session);
     }
     async listSessions(options = {}) {
@@ -1139,7 +1139,7 @@ class RuntimeHostMakaSessionDriverImpl {
                 this.#sessionCreation = undefined;
         }
     }
-    async #createSession(name) {
+    async #createSession(name, thinkingLevel = this.#thinkingLevel) {
         const workspace = this.#workspace.target;
         if (!workspace) {
             throw new Error('A remote Runtime Host Session requires an explicit Project');
@@ -1163,7 +1163,7 @@ class RuntimeHostMakaSessionDriverImpl {
             ...(this.#orchestrationMode === 'default'
                 ? {}
                 : { orchestrationMode: this.#orchestrationMode }),
-            ...(this.#thinkingLevel === undefined ? {} : { thinkingLevel: this.#thinkingLevel }),
+            ...(thinkingLevel === undefined ? {} : { thinkingLevel }),
         }));
         this.#sessionGeneration += 1;
         this.#sessionId = sessionId;

package/dist/tui-copy-catalog.js

@@ -178,6 +178,7 @@ const TUI_COPY_RESOURCES_PICKERS_EN = {
     addAccount: 'add account',
     thinkingLevels: {
         off: 'Off',
+        on: 'On',
         minimal: 'Minimal',
         low: 'Low',
         medium: 'Medium',
@@ -921,6 +922,7 @@ export const TUI_COPY_RESOURCES = {
             addAccount: '添加账号',
             thinkingLevels: {
                 off: '关',
+                on: '开',
                 minimal: '最小',
                 low: '低',
                 medium: '中',
@@ -1045,6 +1047,7 @@ export const TUI_COPY_RESOURCES = {
             addAccount: '新增帳號',
             thinkingLevels: {
                 off: '關',
+                on: '開',
                 minimal: '最小',
                 low: '低',
                 medium: '中',

package/node_modules/@maka/antigravity-acp-plugin/dist/plugin.mjs

@@ -1,6 +1,7 @@
 // ../core/dist/model-thinking.js
 var THINKING_LEVELS = [
   "off",
+  "on",
   "minimal",
   "low",
   "medium",
@@ -8,7 +9,7 @@ var THINKING_LEVELS = [
   "xhigh",
   "max"
 ];
-var DECLARABLE_RELAY_THINKING_LEVELS = THINKING_LEVELS.filter((level) => level !== "off");
+var DECLARABLE_RELAY_THINKING_LEVELS = THINKING_LEVELS.filter((level) => level !== "off" && level !== "on");
 
 // src/model-presentation.ts
 function describeAntigravityModels(models) {

package/node_modules/@maka/core/dist/model-metadata.js

@@ -439,6 +439,14 @@ const COMMAND_CODE_MODEL_METADATA = {
 function buildStaticModelMetadata(active) {
     return {
         anthropic: ANTHROPIC_MODEL_OVERRIDES,
+        opencode: {
+            'claude-sonnet-4-5': {
+                thinkingOptions: ANTHROPIC_MODEL_OVERRIDES['claude-sonnet-4-5'].thinkingOptions,
+            },
+            'claude-haiku-4-5': {
+                thinkingOptions: ANTHROPIC_MODEL_OVERRIDES['claude-haiku-4-5'].thinkingOptions,
+            },
+        },
         openai: OPENAI_GPT6_MODEL_OVERRIDES,
         'claude-subscription': claudeSubscriptionModelMetadata(active),
         // The Command Code Provider-API plan rides the same effort table.

package/node_modules/@maka/core/dist/model-thinking.js

@@ -20,6 +20,7 @@ import { lookupModelMetadata } from './model-metadata.js';
 import { isModelApiProtocol } from './provider-registry.js';
 export const THINKING_LEVELS = [
     'off',
+    'on',
     'minimal',
     'low',
     'medium',
@@ -27,29 +28,12 @@ export const THINKING_LEVELS = [
     'xhigh',
     'max',
 ];
-/**
- * The levels a generic-relay declaration may hold — the vocabulary the
- * settings surfaces offer and the one the data layer admits. `off` is the
- * sole exclusion: it is not an intensity tier but a *disable* wire
- * (`reasoning_effort: 'none'`), and no generic relay is presumed to honor
- * that encoding; built-in providers that support it get `off` from their own
- * metadata instead. `minimal` and every effort tier above are pure
- * intensity values — the user declaring them is the authority on what the
- * relay accepts.
- */
-export const DECLARABLE_RELAY_THINKING_LEVELS = THINKING_LEVELS.filter((level) => level !== 'off');
+/** Relay declarations contain effort tiers; switches require a provider-specific wire. */
+export const DECLARABLE_RELAY_THINKING_LEVELS = THINKING_LEVELS.filter((level) => level !== 'off' && level !== 'on');
 export function isThinkingLevel(value) {
     return typeof value === 'string' && THINKING_LEVELS.includes(value);
 }
-/**
- * Derive the user-facing thinking-level choices from a model's declared
- * `ThinkingOptions`. `none` (OpenAI's off effort) and declared `offBehavior`
- * surface as `'off'`; other effort values map to the same-named
- * `ThinkingLevel`. Raw `toggle` alone is intentionally not enough because some
- * adapters have no real disabled wire. Unknown effort values (not in
- * `ThinkingLevel`) are dropped. Returns `[]` for models with no declared
- * options (miss → no thinking menu, fallback default).
- */
+/** Only expose controls the adapter can encode; unknown effort values are ignored. */
 function deriveThinkingChoices(options) {
     if (!options)
         return [];
@@ -59,10 +43,13 @@ function deriveThinkingChoices(options) {
     for (const effort of options.efforts ?? []) {
         if (effort === 'none')
             choices.add('off');
-        else if (isThinkingLevel(effort))
+        else if (DECLARABLE_RELAY_THINKING_LEVELS.includes(effort)) {
             choices.add(effort);
-        // Unknown effort values (not in ThinkingLevel) are dropped — add the
-        // level to THINKING_LEVELS if a provider introduces a new effort tier.
+        }
+    }
+    // Legacy Claude models need an explicit enabled request and have no effort knob.
+    if (options.offBehavior === 'anthropic-thinking-disabled' && choices.size === 1) {
+        choices.add('on');
     }
     return THINKING_LEVELS.filter((level) => choices.has(level));
 }
@@ -108,12 +95,6 @@ function normalizeModelOverride(entry) {
         return undefined;
     const declared = {};
     if (Array.isArray(entry.thinkingLevels)) {
-        // Declared levels are filtered to the declarable vocabulary, not merely
-        // the level vocabulary: `off` is a disable-wire encoding no generic
-        // relay is presumed to speak, and a declaration table has no business
-        // carrying it. The codec rejects it in persisted documents for the same
-        // reason; normalize silently drops it because it also sanitizes input
-        // that never passed a validator (settings drafts, hand-edited tables).
         const declaredSet = new Set(entry.thinkingLevels.filter((level) => isThinkingLevel(level) &&
             DECLARABLE_RELAY_THINKING_LEVELS.includes(level)));
         if (declaredSet.size > 0) {

package/node_modules/@maka/core/dist/recall.js

@@ -635,7 +635,15 @@ function optionalTimestamp(value) {
         return null;
     return value;
 }
-function eligibleSessions(sessions, filter) {
+/** Complete read-only history corpus for plugin organizers; same privacy and
+ * revision rules as Recall, without the search query's scan-count cap. */
+export async function listRecallHistorySessions(deps, activeSessionId) {
+    const privacy = validateWorkspacePrivacyContext(await deps.getPrivacyContext());
+    if (!privacy.ok || privacy.value.incognitoActive)
+        throw new Error('History is unavailable while workspace privacy cannot be verified or incognito is active');
+    return eligibleSessions(collapseSessionRevisions(await deps.listSessions(), activeSessionId), { includeArchived: false }, Number.POSITIVE_INFINITY);
+}
+function eligibleSessions(sessions, filter, limit = MAX_SESSIONS_SCANNED) {
     return sessions
         .filter((session) => 
     // Retired simulator transcripts are task records, not real history;
@@ -647,7 +655,7 @@ function eligibleSessions(sessions, filter) {
         const byTime = (right.lastMessageAt ?? 0) - (left.lastMessageAt ?? 0);
         return byTime !== 0 ? byTime : left.id.localeCompare(right.id);
     })
-        .slice(0, MAX_SESSIONS_SCANNED);
+        .slice(0, limit);
 }
 async function readFacts(deps, terms, options) {
     if (!deps.searchFacts)

package/node_modules/@maka/core/dist/session.js

@@ -965,3 +965,5 @@ function inferLegacyTurnStatus(messages) {
         return 'failed';
     return 'completed';
 }
+/** Durable provenance for assistant-created workers; visibility is a client preference. */
+export const ASSISTANT_BACKGROUND_SESSION_LABEL = 'personal-assistant-background';

package/node_modules/@maka/core/dist/settings.js

@@ -340,6 +340,7 @@ export function createDefaultSettings() {
             activeTab: 'requests',
         },
         appearance: {
+            showAssistantBackgroundSessions: false,
             workbarTogglePosition: 'titlebar',
             theme: 'auto',
             palette: 'default',
@@ -517,6 +518,7 @@ export function normalizeSettings(input) {
         // position; UI density is no longer a product setting.
         appearance: {
             ...appearanceWithoutLegacyFields,
+            showAssistantBackgroundSessions: base.appearance.showAssistantBackgroundSessions === true,
             workbarTogglePosition: base.appearance.workbarTogglePosition === 'edge' ? 'edge' : 'titlebar',
             palette: isThemePalette(base.appearance.palette) ? base.appearance.palette : 'default',
             // Same fail-closed rule as `palette` above, for the same reason: an

package/node_modules/@maka/core/dist/subagent-settings.js

@@ -81,5 +81,6 @@ export function normalizeSubagentSettings(input) {
             enabled: value.enabled,
         });
     }
-    return { presets };
+    const enabled = input.enabled;
+    return { ...(typeof enabled === 'boolean' ? { enabled } : {}), presets };
 }

package/node_modules/@maka/runtime/dist/ai-sdk-turn.js

@@ -1121,6 +1121,7 @@ export class AiSdkTurn {
                 const requestProjection = shapedProjection;
                 const completedProviderSteps = [];
                 let requestMessages = messages;
+                let finishFeedback;
                 let result;
                 let providerOutcome;
                 let finishReason = 'stop';
@@ -1161,10 +1162,12 @@ export class AiSdkTurn {
                     }
                     const requestSystemPromptBase = joinPromptFragments([
                         systemPrompt,
+                        finishFeedback,
                         finalChildSummaryStep ? CHILD_STEP_BUDGET_FINALIZATION_PROMPT : undefined,
                         toolRuntime.hasSandboxBoundaryDenial() ? SANDBOX_BOUNDARY_DENIED_FOR_TURN : undefined,
                         sandboxBoundaryFinalizationStep ? SANDBOX_BOUNDARY_FINALIZATION_PROMPT : undefined,
                     ]);
+                    finishFeedback = undefined;
                     const codeModeCatalogPrompt = toolMode === 'code_mode'
                         ? renderCodeModeCatalogPrompt(toolRuntime.hasSandboxBoundaryDenial()
                             ? new Map([...nestedTools].filter(([name]) => name !== REQUEST_SANDBOX_BOUNDARY_TOOL_NAME))
@@ -1929,6 +1932,26 @@ export class AiSdkTurn {
                             continue agentLoop;
                         }
                     }
+                    if (mayTakeAnotherStep &&
+                        returnedToolCalls.length === 0 &&
+                        this.deps.backend.beforeTurnFinish &&
+                        this.deps.backend.loadTurnRuntimeEvents &&
+                        this.deps.modelAdapter.mapFinishReason(finishReason) === 'end_turn') {
+                        const decision = await this.deps.backend.beforeTurnFinish({
+                            sessionId: this.deps.backend.sessionId,
+                            turnId,
+                            signal: turnAbortController.signal,
+                        });
+                        if (!decision.allow && !this.aborted && !this.loopStopRequested) {
+                            if ((await input.handoffBoundary?.(turnAbortController.signal, maxSteps === undefined ? null : maxSteps - runtimeSteps)) === 'pause') {
+                                this.handoffPaused = true;
+                                break agentLoop;
+                            }
+                            finishFeedback = decision.feedback;
+                            currentStepMessageId = this.deps.newId();
+                            continue agentLoop;
+                        }
+                    }
                     break agentLoop;
                 }
                 // Refine Tool Availability against the final active set. Deferred

package/node_modules/@maka/runtime/dist/model-adapter.js

@@ -1091,6 +1091,9 @@ export function lowerModelTools(tools) {
                     ? { description: definition.description }
                     : {}),
                 inputSchema: definition.inputSchema,
+                // Responses otherwise promotes optional properties to required filters.
+                // Maka validates the original tool schema at dispatch.
+                strict: false,
             },
     ]));
 }

package/node_modules/@maka/runtime/dist/model-factory.js

@@ -26,7 +26,6 @@ import { createOpenResponses } from '@ai-sdk/open-responses';
 import { createOpenAI } from '@ai-sdk/openai';
 import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
 import { isJSONArray, } from '@ai-sdk/provider';
-import { lookupModelMetadata } from '@maka/core/model-metadata';
 import { modelOverride, resolveThinkingLevel, THINKING_LEVELS, supportsCustomFastServiceTier, thinkingOptionsForModel, thinkingVariantsForConnection, } from '@maka/core/model-thinking';
 import { createOpenAiChatReasoningTransport, createOpenAiChatReasoningTransportState, } from './openai-chat-reasoning-transport.js';
 import { openResponsesUrl } from './provider-urls.js';
@@ -304,54 +303,29 @@ function modelFamilyId(modelId) {
 function claudeFamilyId(modelId) {
     return modelFamilyId(modelId).replace(/^(claude-(?:haiku|opus|sonnet)-\d+)\.(\d+)(?=$|-)/, '$1-$2');
 }
-function defaultOpenAiReasoningEffort(modelId) {
-    const familyModelId = modelFamilyId(modelId);
-    return thinkingOptionsForModel('openai', familyModelId)?.efforts?.includes('medium')
-        ? 'medium'
-        : undefined;
-}
 function openAiResponsesSummary(modelId, reasoningEffort) {
-    return reasoningEffort !== 'none' && defaultOpenAiReasoningEffort(modelId) !== undefined
+    return reasoningEffort !== 'none' &&
+        (thinkingOptionsForModel('openai', modelFamilyId(modelId))?.efforts?.length ?? 0) > 0
         ? { reasoningSummary: 'auto' }
         : {};
 }
-function visibleClaudeThinking(providerType, modelId, thinkingOptions, effort) {
-    const mode = claudeThinkingMode(providerType, modelId, thinkingOptions);
-    if (!mode)
+function claudeThinkingOptions(modelId, level) {
+    if (level === undefined || level === 'off')
         return undefined;
-    const thinking = mode === 'adaptive'
-        ? { type: 'adaptive', display: 'summarized' }
-        : { type: 'enabled', budgetTokens: 1_024 };
-    return {
-        thinking,
-        ...(effort ? { effort } : {}),
-    };
-}
-function claudeThinkingMode(providerType, modelId, thinkingOptions) {
     const familyModelId = claudeFamilyId(modelId);
     if (!familyModelId.startsWith('claude-'))
         return undefined;
-    const providerMetadata = lookupModelMetadata(providerType, modelId);
-    const anthropicMetadata = lookupModelMetadata('anthropic', familyModelId);
     const isKnownBareLegacyClaude4 = /^claude-(?:opus|sonnet)-4$/.test(familyModelId);
-    const effectiveOptions = thinkingOptions ??
-        providerMetadata.thinkingOptions ??
-        anthropicMetadata.thinkingOptions ??
-        thinkingOptionsForModel('anthropic', familyModelId);
-    const supportsThinking = effectiveOptions?.toggle === true ||
-        (effectiveOptions?.efforts?.length ?? 0) > 0 ||
-        providerMetadata.capabilities?.reasoning === true ||
-        anthropicMetadata.capabilities?.reasoning === true ||
-        isKnownBareLegacyClaude4;
-    if (!supportsThinking)
-        return undefined;
     // The SDK's capability table only recognizes dated Claude 4 aliases. The
     // active bare aliases are the same legacy budget-thinking families.
-    if (isKnownBareLegacyClaude4)
-        return 'legacy';
-    return getAnthropicModelCapabilities(familyModelId).supportsAdaptiveThinking
-        ? 'adaptive'
-        : 'legacy';
+    const adaptive = !isKnownBareLegacyClaude4 &&
+        getAnthropicModelCapabilities(familyModelId).supportsAdaptiveThinking;
+    return {
+        thinking: adaptive
+            ? { type: 'adaptive', display: 'summarized' }
+            : { type: 'enabled', budgetTokens: 1_024 },
+        ...(level === 'on' ? {} : { effort: level }),
+    };
 }
 /**
  * The level that asks this model for the least reasoning it accepts, for
@@ -400,33 +374,23 @@ function buildThinkingProviderOptions(connection, modelId, thinkingLevel, runtim
                     }
                     : {};
             }
-            return buildFamilyWire(connection, modelId, level, thinkingOptions, thinkingLevel, runtime);
+            return buildFamilyWire(connection, modelId, level, thinkingOptions, runtime);
         case 'kimi-coding-plan': {
-            // Kimi's coding route has no off wire. Check the raw argument, not the
-            // normalized level: the entry gate above drops unsupported levels to
-            // undefined (default max), but an explicit off must be rejected, never
-            // silently upgraded to max. Today off cannot reach this branch through
-            // the UI (variants exclude it), but a direct runtime caller or a future
-            // models.dev `none` declaration must fail loudly, and the wire-contract
-            // sweep keeps that tripwire armed.
-            if (thinkingLevel === 'off')
+            if (!level || level === 'off' || level === 'on')
                 return {};
-            const effort = level ?? 'max';
             if (runtime.wire === 'openai-chat') {
                 // The kimiCodingPlan provider-options namespace is the
                 // openai-compatible adapter name; ai-sdk resolves its camelCase
                 // alias to the kimi-coding-plan schema key (reasoning_effort).
                 return {
-                    kimiCodingPlan: { reasoningEffort: effort },
+                    kimiCodingPlan: { reasoningEffort: level },
                 };
             }
             return {
                 anthropic: modelId === 'k3' || modelId === 'k3-256k'
                     ? {
-                        // K3 (and its 256k-context variant) supports adaptive thinking
-                        // only; effort defaults to max when unset.
                         thinking: { type: 'adaptive' },
-                        effort,
+                        effort: level,
                     }
                     : modelId === 'kimi-for-coding'
                         ? {
@@ -434,7 +398,7 @@ function buildThinkingProviderOptions(connection, modelId, thinkingLevel, runtim
                             // Anthropic AI SDK also requires a compatibility budget and
                             // otherwise injects the same value with a warning.
                             thinking: { type: 'enabled', budgetTokens: 1_024 },
-                            effort,
+                            effort: level,
                         }
                         : {
                         // kimi-for-coding-highspeed has no declared effort and no
@@ -450,17 +414,14 @@ function buildThinkingProviderOptions(connection, modelId, thinkingLevel, runtim
         case 'MiniMax':
         case 'MiniMax-cn': {
             let reasoning = {};
-            const summarizedThinking = connection.providerType === 'anthropic' &&
-                (thinkingLevel === undefined || level !== undefined)
-                ? visibleClaudeThinking(connection.providerType, modelId, thinkingOptions, level)
-                : undefined;
+            const summarizedThinking = connection.providerType === 'anthropic' ? claudeThinkingOptions(modelId, level) : undefined;
             if (level === 'off' && thinkingOptions?.offBehavior === 'anthropic-thinking-disabled') {
                 reasoning = { thinking: { type: 'disabled' } };
             }
             else if (summarizedThinking) {
                 reasoning = summarizedThinking;
             }
-            else if (level && level !== 'off') {
+            else if (level && level !== 'off' && level !== 'on') {
                 reasoning = { effort: level };
             }
             return {
@@ -472,30 +433,17 @@ function buildThinkingProviderOptions(connection, modelId, thinkingLevel, runtim
                 },
             };
         }
-        case 'openai-codex': {
-            const reasoningEffort = level === 'off'
-                ? 'none'
-                : (level ??
-                    (thinkingLevel === undefined ? defaultOpenAiReasoningEffort(modelId) : undefined));
-            return {
-                openai: {
-                    store: false,
-                    textVerbosity: 'medium',
-                    ...openAiResponsesSummary(modelId, reasoningEffort),
-                    ...(reasoningEffort ? { reasoningEffort } : {}),
-                },
-            };
-        }
+        case 'openai-codex':
         case 'openai': {
-            const usesResponses = runtime.wire === 'openai-responses';
-            const reasoningEffort = level === 'off'
-                ? 'none'
-                : (level ??
-                    (thinkingLevel === undefined ? defaultOpenAiReasoningEffort(modelId) : undefined));
+            const isCodex = connection.providerType === 'openai-codex';
+            const reasoningEffort = level === 'off' ? 'none' : level;
             return {
                 openai: {
                     store: false,
-                    ...(usesResponses ? openAiResponsesSummary(modelId, reasoningEffort) : {}),
+                    ...(isCodex ? { textVerbosity: 'medium' } : {}),
+                    ...(runtime.wire === 'openai-responses'
+                        ? openAiResponsesSummary(modelId, reasoningEffort)
+                        : {}),
                     ...(reasoningEffort ? { reasoningEffort } : {}),
                 },
             };
@@ -520,11 +468,11 @@ function buildThinkingProviderOptions(connection, modelId, thinkingLevel, runtim
                     },
                 };
             }
-            return buildFamilyWire(connection, modelId, level, thinkingOptions, thinkingLevel, runtime);
+            return buildFamilyWire(connection, modelId, level, thinkingOptions, runtime);
         case 'volcengine-ark':
             return {
                 [toCamelCase(connection.providerType)]: {
-                    thinking: { type: level === 'off' ? 'disabled' : 'enabled' },
+                    ...(level ? { thinking: { type: level === 'off' ? 'disabled' : 'enabled' } } : {}),
                     ...(level && level !== 'off' ? { reasoningEffort: level } : {}),
                 },
             };
@@ -564,7 +512,7 @@ function buildThinkingProviderOptions(connection, modelId, thinkingLevel, runtim
         // above (level is defined only when metadata declares it) is what makes
         // this safe to generalize: undeclared models never reach the wire.
         default:
-            return buildFamilyWire(connection, modelId, level, thinkingOptions, thinkingLevel, runtime);
+            return buildFamilyWire(connection, modelId, level, thinkingOptions, runtime);
     }
 }
 function withParallelToolCallOptions(connection, modelId, options, runtime) {
@@ -601,9 +549,9 @@ function withParallelToolCallOptions(connection, modelId, options, runtime) {
         },
     };
 }
-function buildFamilyWire(connection, modelId, level, thinkingOptions, requestedLevel, runtime) {
+function buildFamilyWire(connection, modelId, level, thinkingOptions, runtime) {
     const { adapter, wire, reasoningReplay } = runtime;
-    const explicitReasoningEffort = level ? (level === 'off' ? 'none' : level) : undefined;
+    const explicitReasoningEffort = level && level !== 'on' ? (level === 'off' ? 'none' : level) : undefined;
     // Provider selection and reasoning continuation are independent. The OpenAI
     // provider reads its provider-options namespace; the Open Responses provider
     // consumes a provider-native reasoningEffort through the same namespace,
@@ -625,34 +573,26 @@ function buildFamilyWire(connection, modelId, level, thinkingOptions, requestedL
         const serviceTier = supportsCustomFastServiceTier(connection, modelId)
             ? modelOverride(connection, modelId)?.serviceTier
             : undefined;
-        const reasoningEffort = explicitReasoningEffort ??
-            (requestedLevel === undefined ? defaultOpenAiReasoningEffort(modelId) : undefined);
         return {
             openai: {
                 store: false,
                 ...(reasons || reasoningReplay.contract.reasoningReplay === 'encrypted-content'
                     ? { forceReasoning: true }
                     : {}),
-                ...openAiResponsesSummary(modelId, reasoningEffort),
-                ...(reasoningEffort ? { reasoningEffort } : {}),
+                ...openAiResponsesSummary(modelId, explicitReasoningEffort),
+                ...(explicitReasoningEffort ? { reasoningEffort: explicitReasoningEffort } : {}),
                 ...(serviceTier ? { serviceTier } : {}),
             },
         };
     }
-    if (wire === 'anthropic-messages' && (requestedLevel === undefined || level !== undefined)) {
-        const reasoning = visibleClaudeThinking(connection.providerType, modelId, thinkingOptions, explicitReasoningEffort);
+    if (wire === 'anthropic-messages') {
+        if (level === 'off' && thinkingOptions?.offBehavior === 'anthropic-thinking-disabled') {
+            return { anthropic: { thinking: { type: 'disabled' } } };
+        }
+        const reasoning = claudeThinkingOptions(modelId, level);
         if (reasoning)
             return { anthropic: reasoning };
     }
-    if (wire === 'openai-chat' && adapter.kind === 'openai-compatible') {
-        const reasoningEffort = explicitReasoningEffort ??
-            (requestedLevel === undefined ? defaultOpenAiReasoningEffort(modelId) : undefined);
-        if (reasoningEffort) {
-            return {
-                [openAiCompatibleProviderOptionsKey(connection)]: { reasoningEffort },
-            };
-        }
-    }
     if (!explicitReasoningEffort)
         return {};
     switch (adapter.kind) {