shortcutxl 0.3.76 → 0.3.78

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.3.78]
+
+- **More performant spreadsheet operations** - Read/write operations should be much faster and less buggy.
+- **Linked local files** - Open local file links from agent responses in both the CLI and native app.
+- **Safer read-only modes** - Ask and Plan modes no longer expose shell execution, and mode switching avoids unnecessary skill scans.
+- **Native app polish** - Refreshed the native app design and improved chat autoscrolling during active sessions.
+- **Auto-update reminders** - Update reminders will be surfaced in open terminal windows.
+
+## [0.3.77]
+
+- **Native app file mentions** - Type `@` in the native app to search and attach workspace files with the same completion behavior as the CLI.
+- **Custom model setup** - A bundled skill now guides configuration of compatible custom model providers.
+- **Subagent permissions** - CLI subagents inherit the active permission policy and surface nested approval requests more clearly.
+
 ## [0.3.76]
 
 - **Claude Opus 5** - Claude Opus 5 is now available as ShortcutXL's high-accuracy Opus option.

package/dist/ai/models.d.ts

@@ -1,5 +1,5 @@
 import { MODELS } from './models.generated.js';
-import type { Api, KnownProvider, Model, Usage } from './types.js';
+import type { Api, KnownProvider, Model, ModelCapabilities, ReasoningLevel, Usage } from './types.js';
 type ModelApi<TProvider extends KnownProvider, TModelId extends keyof (typeof MODELS)[TProvider]> = (typeof MODELS)[TProvider][TModelId] extends {
     api: infer TApi;
 } ? TApi extends Api ? TApi : never : never;
@@ -8,13 +8,17 @@ export declare function getProviders(): KnownProvider[];
 export declare function getModels<TProvider extends KnownProvider>(provider: TProvider): Model<ModelApi<TProvider, keyof (typeof MODELS)[TProvider]>>[];
 export declare function calculateCost<TApi extends Api>(model: Model<TApi>, usage: Usage): Usage['cost'];
 /**
- * Check if a model supports xhigh thinking level.
+ * Return the model's declared reasoning contract.
  *
- * Supported today:
- * - Shortcut's current and legacy OpenAI reasoning models
- * - Anthropic Messages API Opus models (xhigh maps to adaptive effort "max")
+ * Models that only declare `reasoning: true` expose no configurable wire
+ * control: the provider default is represented as a fixed `high` product state.
+ * Shortcut-served models always provide an explicit contract in the catalog.
  */
-export declare function supportsXhigh<TApi extends Api>(model: Model<TApi>): boolean;
+export declare function getModelReasoningCapabilities<TApi extends Api>(model: Model<TApi>): ModelCapabilities['reasoning'] | undefined;
+export declare function getModelReasoningLevels<TApi extends Api>(model: Model<TApi>): ReasoningLevel[];
+export declare function assertModelSupportsReasoningLevel<TApi extends Api>(model: Model<TApi>, level: ReasoningLevel): void;
+/** Resolve a stale/cross-model selection to the target model's declared default. */
+export declare function resolveModelReasoningLevel<TApi extends Api>(model: Model<TApi>, requested: ReasoningLevel | undefined): ReasoningLevel;
 /**
  * Check if two models are equal by comparing both their id and provider.
  * Returns false if either model is null or undefined.

package/dist/ai/models.generated.d.ts

@@ -7,6 +7,14 @@ export declare const MODELS: {
             provider: string;
             baseUrl: string;
             reasoning: true;
+            capabilities: {
+                reasoning: {
+                    readonly control: "budget";
+                    readonly defaultLevel: "minimal";
+                    readonly levels: readonly ["minimal", "low", "medium", "high"];
+                    readonly supportsOff: true;
+                };
+            };
             input: ("text" | "image")[];
             cost: {
                 input: number;
@@ -24,6 +32,14 @@ export declare const MODELS: {
             provider: string;
             baseUrl: string;
             reasoning: true;
+            capabilities: {
+                reasoning: {
+                    readonly control: "budget";
+                    readonly defaultLevel: "minimal";
+                    readonly levels: readonly ["minimal", "low", "medium", "high"];
+                    readonly supportsOff: true;
+                };
+            };
             input: ("text" | "image")[];
             cost: {
                 input: number;
@@ -130,6 +146,14 @@ export declare const MODELS: {
             provider: string;
             baseUrl: string;
             reasoning: true;
+            capabilities: {
+                reasoning: {
+                    readonly control: "thinking-level";
+                    readonly defaultLevel: "minimal";
+                    readonly levels: readonly ["minimal", "low", "medium", "high"];
+                    readonly supportsOff: false;
+                };
+            };
             input: ("text" | "image")[];
             cost: {
                 input: number;
@@ -147,6 +171,14 @@ export declare const MODELS: {
             provider: string;
             baseUrl: string;
             reasoning: true;
+            capabilities: {
+                reasoning: {
+                    readonly control: "thinking-level";
+                    readonly defaultLevel: "low";
+                    readonly levels: readonly ["low", "high"];
+                    readonly supportsOff: false;
+                };
+            };
             input: ("text" | "image")[];
             cost: {
                 input: number;
@@ -164,6 +196,14 @@ export declare const MODELS: {
             provider: string;
             baseUrl: string;
             reasoning: true;
+            capabilities: {
+                reasoning: {
+                    readonly control: "thinking-level";
+                    readonly defaultLevel: "low";
+                    readonly levels: readonly ["low", "medium", "high"];
+                    readonly supportsOff: false;
+                };
+            };
             input: ("text" | "image")[];
             cost: {
                 input: number;
@@ -181,6 +221,14 @@ export declare const MODELS: {
             provider: string;
             baseUrl: string;
             reasoning: true;
+            capabilities: {
+                reasoning: {
+                    readonly control: "thinking-level";
+                    readonly defaultLevel: "low";
+                    readonly levels: readonly ["low", "medium", "high"];
+                    readonly supportsOff: false;
+                };
+            };
             input: ("text" | "image")[];
             cost: {
                 input: number;
@@ -319,6 +367,14 @@ export declare const MODELS: {
             provider: string;
             baseUrl: string;
             reasoning: true;
+            capabilities: {
+                reasoning: {
+                    readonly control: "thinking-level";
+                    readonly defaultLevel: "minimal";
+                    readonly levels: readonly ["minimal", "low", "medium", "high"];
+                    readonly supportsOff: false;
+                };
+            };
             input: ("text" | "image")[];
             cost: {
                 input: number;
@@ -336,6 +392,14 @@ export declare const MODELS: {
             provider: string;
             baseUrl: string;
             reasoning: true;
+            capabilities: {
+                reasoning: {
+                    readonly control: "thinking-level";
+                    readonly defaultLevel: "low";
+                    readonly levels: readonly ["low", "high"];
+                    readonly supportsOff: false;
+                };
+            };
             input: ("text" | "image")[];
             cost: {
                 input: number;
@@ -353,6 +417,14 @@ export declare const MODELS: {
             provider: string;
             baseUrl: string;
             reasoning: true;
+            capabilities: {
+                reasoning: {
+                    readonly control: "thinking-level";
+                    readonly defaultLevel: "low";
+                    readonly levels: readonly ["low", "medium", "high"];
+                    readonly supportsOff: false;
+                };
+            };
             input: ("text" | "image")[];
             cost: {
                 input: number;

package/dist/ai/models.generated.js

@@ -1,5 +1,29 @@
 // This file is auto-generated by scripts/generate-models.ts.
 // Do not edit manually - run 'pnpm run generate-models' to update.
+const HAIKU_45_REASONING = {
+    control: 'budget',
+    defaultLevel: 'minimal',
+    levels: ['minimal', 'low', 'medium', 'high'],
+    supportsOff: true
+};
+const GEMINI_3_FLASH_REASONING = {
+    control: 'thinking-level',
+    defaultLevel: 'minimal',
+    levels: ['minimal', 'low', 'medium', 'high'],
+    supportsOff: false
+};
+const GEMINI_3_PRO_REASONING = {
+    control: 'thinking-level',
+    defaultLevel: 'low',
+    levels: ['low', 'high'],
+    supportsOff: false
+};
+const GEMINI_31_PRO_REASONING = {
+    control: 'thinking-level',
+    defaultLevel: 'low',
+    levels: ['low', 'medium', 'high'],
+    supportsOff: false
+};
 export const MODELS = {
     anthropic: {
         'claude-haiku-4-5': {
@@ -9,6 +33,7 @@ export const MODELS = {
             provider: 'anthropic',
             baseUrl: 'https://api.anthropic.com',
             reasoning: true,
+            capabilities: { reasoning: HAIKU_45_REASONING },
             input: ['text', 'image'],
             cost: {
                 input: 1,
@@ -26,6 +51,7 @@ export const MODELS = {
             provider: 'anthropic',
             baseUrl: 'https://api.anthropic.com',
             reasoning: true,
+            capabilities: { reasoning: HAIKU_45_REASONING },
             input: ['text', 'image'],
             cost: {
                 input: 1,
@@ -132,6 +158,7 @@ export const MODELS = {
             provider: 'google',
             baseUrl: 'https://generativelanguage.googleapis.com/v1beta',
             reasoning: true,
+            capabilities: { reasoning: GEMINI_3_FLASH_REASONING },
             input: ['text', 'image'],
             cost: {
                 input: 0.5,
@@ -149,6 +176,7 @@ export const MODELS = {
             provider: 'google',
             baseUrl: 'https://generativelanguage.googleapis.com/v1beta',
             reasoning: true,
+            capabilities: { reasoning: GEMINI_3_PRO_REASONING },
             input: ['text', 'image'],
             cost: {
                 input: 2,
@@ -166,6 +194,7 @@ export const MODELS = {
             provider: 'google',
             baseUrl: 'https://generativelanguage.googleapis.com/v1beta',
             reasoning: true,
+            capabilities: { reasoning: GEMINI_31_PRO_REASONING },
             input: ['text', 'image'],
             cost: {
                 input: 2,
@@ -183,6 +212,7 @@ export const MODELS = {
             provider: 'google',
             baseUrl: 'https://generativelanguage.googleapis.com/v1beta',
             reasoning: true,
+            capabilities: { reasoning: GEMINI_31_PRO_REASONING },
             input: ['text', 'image'],
             cost: {
                 input: 2,
@@ -321,6 +351,7 @@ export const MODELS = {
             provider: 'google-vertex',
             baseUrl: 'https://{location}-aiplatform.googleapis.com',
             reasoning: true,
+            capabilities: { reasoning: GEMINI_3_FLASH_REASONING },
             input: ['text', 'image'],
             cost: {
                 input: 0.5,
@@ -338,6 +369,7 @@ export const MODELS = {
             provider: 'google-vertex',
             baseUrl: 'https://{location}-aiplatform.googleapis.com',
             reasoning: true,
+            capabilities: { reasoning: GEMINI_3_PRO_REASONING },
             input: ['text', 'image'],
             cost: {
                 input: 2,
@@ -355,6 +387,7 @@ export const MODELS = {
             provider: 'google-vertex',
             baseUrl: 'https://{location}-aiplatform.googleapis.com',
             reasoning: true,
+            capabilities: { reasoning: GEMINI_31_PRO_REASONING },
             input: ['text', 'image'],
             cost: {
                 input: 2,

package/dist/ai/models.js

@@ -1,4 +1,3 @@
-import { SHORTCUT_OPENAI_MODEL_ID } from '../model-ids.js';
 import { MODELS } from './models.generated.js';
 const modelRegistry = new Map();
 // Initialize registry from MODELS on module load
@@ -32,22 +31,46 @@ export function calculateCost(model, usage) {
         usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
     return usage.cost;
 }
+const PROVIDER_DEFAULT_REASONING = {
+    control: 'fixed',
+    defaultLevel: 'high',
+    levels: ['high'],
+    supportsOff: false
+};
 /**
- * Check if a model supports xhigh thinking level.
+ * Return the model's declared reasoning contract.
  *
- * Supported today:
- * - Shortcut's current and legacy OpenAI reasoning models
- * - Anthropic Messages API Opus models (xhigh maps to adaptive effort "max")
+ * Models that only declare `reasoning: true` expose no configurable wire
+ * control: the provider default is represented as a fixed `high` product state.
+ * Shortcut-served models always provide an explicit contract in the catalog.
  */
-export function supportsXhigh(model) {
-    const modelId = model.id.startsWith('openai/') ? model.id.slice('openai/'.length) : model.id;
-    if (modelId.includes(SHORTCUT_OPENAI_MODEL_ID) || modelId.includes('gpt-5.5')) {
-        return true;
-    }
-    if (model.api === 'anthropic-messages') {
-        return model.id.toLowerCase().includes('opus');
+export function getModelReasoningCapabilities(model) {
+    if (!model.reasoning)
+        return undefined;
+    return model.capabilities?.reasoning ?? PROVIDER_DEFAULT_REASONING;
+}
+export function getModelReasoningLevels(model) {
+    const capabilities = getModelReasoningCapabilities(model);
+    if (!capabilities)
+        return ['off'];
+    return [...(capabilities.supportsOff ? ['off'] : []), ...capabilities.levels];
+}
+export function assertModelSupportsReasoningLevel(model, level) {
+    const available = getModelReasoningLevels(model);
+    if (!available.includes(level)) {
+        throw new Error(`Reasoning level "${level}" is not supported by ${model.provider}/${model.id}. ` +
+            `Supported levels: ${available.join(', ')}.`);
     }
-    return false;
+}
+/** Resolve a stale/cross-model selection to the target model's declared default. */
+export function resolveModelReasoningLevel(model, requested) {
+    const capabilities = getModelReasoningCapabilities(model);
+    if (requested === undefined)
+        return capabilities?.defaultLevel ?? 'off';
+    const available = getModelReasoningLevels(model);
+    if (available.includes(requested))
+        return requested;
+    return capabilities?.defaultLevel ?? 'off';
 }
 /**
  * Check if two models are equal by comparing both their id and provider.

package/dist/ai/providers/anthropic.d.ts

@@ -1,6 +1,6 @@
 import { type ShortcutXLModelStreamErrorDetails } from '../../contracts/model-stream.js';
-import type { SimpleStreamOptions, StreamFunction, StreamOptions } from '../types.js';
-export type AnthropicEffort = 'low' | 'medium' | 'high' | 'max';
+import type { Context, Model, SimpleStreamOptions, StreamFunction, StreamOptions } from '../types.js';
+export type AnthropicEffort = 'low' | 'medium' | 'high' | 'xhigh' | 'max';
 export interface AnthropicOptions extends StreamOptions {
     /**
      * Enable extended thinking.
@@ -31,5 +31,7 @@ export interface AnthropicOptions extends StreamOptions {
 }
 export declare const streamAnthropic: StreamFunction<'anthropic-messages', AnthropicOptions>;
 export declare const streamSimpleAnthropic: StreamFunction<'anthropic-messages', SimpleStreamOptions>;
+/** Serialize one Anthropic request for either the SDK stream or a raw invoke transport. */
+export declare function buildAnthropicMessagesRequest(model: Model<'anthropic-messages'>, context: Context, options: SimpleStreamOptions | undefined, stream: boolean): Record<string, unknown>;
 export declare function anthropicTerminalStopErrorDetails(reason: string | null | undefined): ShortcutXLModelStreamErrorDetails | undefined;
 //# sourceMappingURL=anthropic.d.ts.map

package/dist/ai/providers/anthropic.js

@@ -1,7 +1,7 @@
 import Anthropic from '@anthropic-ai/sdk';
 import { PROVIDER_REFUSAL_ERROR_CODE, safeModelStreamErrorMessage } from '../../contracts/model-stream.js';
 import { getEnvApiKey } from '../env-api-keys.js';
-import { calculateCost } from '../models.js';
+import { assertModelSupportsReasoningLevel, calculateCost } from '../models.js';
 import { AssistantMessageEventStream } from '../utils/event-stream.js';
 import { parseStreamingJson } from '../utils/json-parse.js';
 import { sanitizeSurrogates } from '../utils/sanitize-unicode.js';
@@ -381,17 +381,19 @@ export const streamAnthropic = (model, context, options) => {
  */
 const ADAPTIVE_THINKING_MODELS = ['opus-5', 'opus-4-8', 'sonnet-5', 'fable-5'];
 /** Check if a model uses adaptive thinking. */
-function supportsAdaptiveThinking(modelId) {
-    const normalized = modelId.toLowerCase();
+function supportsAdaptiveThinking(model) {
+    const configuredControl = model.capabilities?.reasoning?.control;
+    if (configuredControl)
+        return configuredControl === 'adaptive-effort';
+    const normalized = model.id.toLowerCase();
     return ADAPTIVE_THINKING_MODELS.some((id) => normalized.includes(id));
 }
 /**
- * Map ThinkingLevel to Anthropic effort levels for adaptive thinking.
+ * Map provider-neutral reasoning effort to Anthropic adaptive effort.
  *
- * Every Claude model Shortcut serves accepts `max`, so `xhigh` maps to `max`.
- * The guard just keeps a hypothetical non-adaptive model from 400ing on `max`.
+ * This is only called for adaptive models, where `max` is a native effort.
  */
-function mapThinkingLevelToEffort(level, modelId) {
+function mapReasoningLevel(level) {
     switch (level) {
         case 'minimal':
             return 'low';
@@ -402,39 +404,57 @@ function mapThinkingLevelToEffort(level, modelId) {
         case 'high':
             return 'high';
         case 'xhigh':
-            return supportsAdaptiveThinking(modelId) ? 'max' : 'high';
+        case 'max':
+            return level;
         default:
             return 'high';
     }
 }
-export const streamSimpleAnthropic = (model, context, options) => {
-    const apiKey = options?.apiKey || getEnvApiKey(model.provider);
-    if (!apiKey) {
-        throw new Error(`No API key for provider: ${model.provider}`);
+function mapToolChoice(toolChoice) {
+    if (!toolChoice)
+        return undefined;
+    if (typeof toolChoice === 'object')
+        return { type: 'tool', name: toolChoice.name };
+    return toolChoice === 'required' ? 'any' : toolChoice;
+}
+function resolveSimpleAnthropicOptions(model, options) {
+    const base = buildBaseOptions(model, options, options?.apiKey);
+    const toolChoice = mapToolChoice(options?.toolChoice);
+    if (options?.reasoning === undefined) {
+        return { ...base, toolChoice };
     }
-    const base = buildBaseOptions(model, options, apiKey);
-    if (!options?.reasoning) {
-        return streamAnthropic(model, context, {
-            ...base,
-            thinkingEnabled: false
-        });
+    if (!model.capabilities?.reasoning) {
+        return { ...base, toolChoice };
     }
-    // Current served Claude models use adaptive thinking with an effort level.
-    // Older models use budget-based thinking.
-    if (supportsAdaptiveThinking(model.id)) {
-        const effort = mapThinkingLevelToEffort(options.reasoning, model.id);
-        return streamAnthropic(model, context, {
+    assertModelSupportsReasoningLevel(model, options.reasoning);
+    if (options.reasoning === 'off') {
+        return { ...base, thinkingEnabled: false, toolChoice };
+    }
+    if (supportsAdaptiveThinking(model)) {
+        return {
             ...base,
+            effort: mapReasoningLevel(options.reasoning),
             thinkingEnabled: true,
-            effort
-        });
+            toolChoice
+        };
     }
     const adjusted = adjustMaxTokensForThinking(base.maxTokens || 0, model.maxTokens, options.reasoning);
-    return streamAnthropic(model, context, {
+    return {
         ...base,
         maxTokens: adjusted.maxTokens,
+        thinkingBudgetTokens: adjusted.thinkingBudget,
         thinkingEnabled: true,
-        thinkingBudgetTokens: adjusted.thinkingBudget
+        toolChoice
+    };
+}
+export const streamSimpleAnthropic = (model, context, options) => {
+    const apiKey = options?.apiKey || getEnvApiKey(model.provider);
+    if (!apiKey) {
+        throw new Error(`No API key for provider: ${model.provider}`);
+    }
+    return streamAnthropic(model, context, {
+        ...resolveSimpleAnthropicOptions(model, options),
+        apiKey
     });
 };
 function isOAuthToken(apiKey) {
@@ -443,7 +463,7 @@ function isOAuthToken(apiKey) {
 function createClient(model, apiKey, interleavedThinking, optionsHeaders, fetchOptions, fetchImpl) {
     // Adaptive thinking models (Opus 4.6, Sonnet 4.6) have interleaved thinking built-in.
     // The beta header is deprecated on Opus 4.6 and redundant on Sonnet 4.6, so skip it.
-    const needsInterleavedBeta = interleavedThinking && !supportsAdaptiveThinking(model.id);
+    const needsInterleavedBeta = interleavedThinking && !supportsAdaptiveThinking(model);
     const betaFeatures = ['fine-grained-tool-streaming-2025-05-14'];
     if (needsInterleavedBeta) {
         betaFeatures.push('interleaved-thinking-2025-05-14');
@@ -490,7 +510,7 @@ function buildParams(model, context, options) {
     }
     // Configure adaptive thinking for current models or budget-based thinking for older models.
     if (options?.thinkingEnabled && model.reasoning) {
-        if (supportsAdaptiveThinking(model.id)) {
+        if (supportsAdaptiveThinking(model)) {
             // Adaptive thinking: Claude decides when and how much to think
             params.thinking = { type: 'adaptive', display: 'summarized' };
             if (options.effort) {
@@ -505,6 +525,9 @@ function buildParams(model, context, options) {
             };
         }
     }
+    else if (options?.thinkingEnabled === false && model.reasoning) {
+        params.thinking = { type: 'disabled' };
+    }
     if (options?.metadata) {
         const userId = options.metadata.user_id;
         if (typeof userId === 'string') {
@@ -521,6 +544,13 @@ function buildParams(model, context, options) {
     }
     return params;
 }
+/** Serialize one Anthropic request for either the SDK stream or a raw invoke transport. */
+export function buildAnthropicMessagesRequest(model, context, options, stream) {
+    return {
+        ...buildParams(model, context, resolveSimpleAnthropicOptions(model, options)),
+        stream
+    };
+}
 // Normalize tool call IDs to match Anthropic's required pattern and length
 function normalizeToolCallId(id) {
     return id.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 64);

package/dist/ai/providers/azure-openai-responses.d.ts

@@ -1,6 +1,7 @@
 import type { SimpleStreamOptions, StreamFunction, StreamOptions } from '../types.js';
+import { type OpenAIReasoningEffort } from './openai-reasoning.js';
 export interface AzureOpenAIResponsesOptions extends StreamOptions {
-    reasoningEffort?: 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
+    reasoningEffort?: OpenAIReasoningEffort;
     reasoningSummary?: 'auto' | 'detailed' | 'concise' | null;
     azureApiVersion?: string;
     azureResourceName?: string;

package/dist/ai/providers/azure-openai-responses.js

@@ -1,9 +1,9 @@
 import { AzureOpenAI } from 'openai';
 import { getEnvApiKey } from '../env-api-keys.js';
-import { supportsXhigh } from '../models.js';
 import { AssistantMessageEventStream } from '../utils/event-stream.js';
+import { resolveOpenAIReasoningEffort } from './openai-reasoning.js';
 import { convertResponsesMessages, convertResponsesTools, processResponsesStream } from './openai-responses-shared.js';
-import { buildBaseOptions, clampReasoning } from './simple-options.js';
+import { buildBaseOptions } from './simple-options.js';
 const DEFAULT_AZURE_API_VERSION = 'v1';
 const AZURE_TOOL_CALL_PROVIDERS = new Set(['openai', 'opencode', 'azure-openai-responses']);
 function parseDeploymentNameMap(value) {
@@ -88,9 +88,7 @@ export const streamSimpleAzureOpenAIResponses = (model, context, options) => {
         throw new Error(`No API key for provider: ${model.provider}`);
     }
     const base = buildBaseOptions(model, options, apiKey);
-    const reasoningEffort = supportsXhigh(model)
-        ? options?.reasoning
-        : clampReasoning(options?.reasoning);
+    const reasoningEffort = resolveOpenAIReasoningEffort(model, options?.reasoning);
     return streamAzureOpenAIResponses(model, context, {
         ...base,
         reasoningEffort
@@ -160,25 +158,11 @@ function buildParams(model, context, options, deploymentName) {
     if (model.reasoning) {
         if (options?.reasoningEffort || options?.reasoningSummary) {
             params.reasoning = {
-                effort: options?.reasoningEffort || 'medium',
+                effort: (options?.reasoningEffort || 'medium'),
                 summary: options?.reasoningSummary || 'auto'
             };
             params.include = ['reasoning.encrypted_content'];
         }
-        else {
-            if (model.name.toLowerCase().startsWith('gpt-5')) {
-                // Jesus Christ, see https://community.openai.com/t/need-reasoning-false-option-for-gpt-5/1351588/7
-                messages.push({
-                    role: 'developer',
-                    content: [
-                        {
-                            type: 'input_text',
-                            text: '# Juice: 0 !important'
-                        }
-                    ]
-                });
-            }
-        }
     }
     return params;
 }

package/dist/ai/providers/google-vertex.d.ts

@@ -1,7 +1,9 @@
-import type { SimpleStreamOptions, StreamFunction, StreamOptions } from '../types.js';
+import type { Context, Model, SimpleStreamOptions, StreamFunction, StreamOptions } from '../types.js';
 import { type GoogleThinkingLevel } from './google-shared.js';
 export interface GoogleVertexOptions extends StreamOptions {
-    toolChoice?: 'auto' | 'none' | 'any';
+    toolChoice?: 'auto' | 'none' | 'any' | {
+        readonly name: string;
+    };
     thinking?: {
         enabled: boolean;
         budgetTokens?: number;
@@ -12,4 +14,8 @@ export interface GoogleVertexOptions extends StreamOptions {
 }
 export declare const streamGoogleVertex: StreamFunction<'google-vertex', GoogleVertexOptions>;
 export declare const streamSimpleGoogleVertex: StreamFunction<'google-vertex', SimpleStreamOptions>;
+/** Serialize the provider-neutral request into the Vertex REST wire shape. */
+export declare function buildGoogleVertexRequest(model: Model<'google-vertex'>, context: Context, options: SimpleStreamOptions | undefined): Record<string, unknown>;
+/** Build the api-v2 Vertex-shaped endpoint used by CLI and embedded transports. */
+export declare function googleVertexGatewayEndpoint(baseUrl: string, modelId: string, operation: 'generateContent' | 'streamGenerateContent'): string;
 //# sourceMappingURL=google-vertex.d.ts.map