shortcutxl 0.3.76 → 0.3.78

package/dist/ai/providers/google-vertex.js

@@ -1,9 +1,9 @@
 import { GoogleGenAI, ThinkingLevel } from '@google/genai';
-import { calculateCost } from '../models.js';
+import { assertModelSupportsReasoningLevel, calculateCost } from '../models.js';
 import { AssistantMessageEventStream } from '../utils/event-stream.js';
 import { sanitizeSurrogates } from '../utils/sanitize-unicode.js';
 import { convertMessages, convertTools, isGemini3FlashModelId, isGemini3ProModelId, isThinkingPart, mapStopReason, mapToolChoice, retainThoughtSignature } from './google-shared.js';
-import { buildBaseOptions, clampReasoning } from './simple-options.js';
+import { buildBaseOptions } from './simple-options.js';
 const API_VERSION = 'v1';
 const THINKING_LEVEL_MAP = {
     THINKING_LEVEL_UNSPECIFIED: ThinkingLevel.THINKING_LEVEL_UNSPECIFIED,
@@ -226,32 +226,36 @@ export const streamGoogleVertex = (model, context, options) => {
     return stream;
 };
 export const streamSimpleGoogleVertex = (model, context, options) => {
-    const base = buildBaseOptions(model, options, undefined);
-    if (!options?.reasoning) {
-        return streamGoogleVertex(model, context, {
-            ...base,
-            thinking: { enabled: false }
-        });
-    }
-    const effort = clampReasoning(options.reasoning);
+    return streamGoogleVertex(model, context, resolveSimpleGoogleVertexOptions(model, options));
+};
+function resolveSimpleGoogleVertexOptions(model, options) {
+    const base = {
+        ...buildBaseOptions(model, options, undefined),
+        toolChoice: typeof options?.toolChoice === 'object'
+            ? options.toolChoice
+            : options?.toolChoice === 'required'
+                ? 'any'
+                : options?.toolChoice
+    };
+    if (options?.reasoning === undefined)
+        return base;
+    if (!model.capabilities?.reasoning)
+        return base;
+    assertModelSupportsReasoningLevel(model, options.reasoning);
+    if (options.reasoning === 'off')
+        return { ...base, thinking: { enabled: false } };
     const geminiModel = model;
     if (isGemini3ProModelId(geminiModel.id) || isGemini3FlashModelId(geminiModel.id)) {
-        return streamGoogleVertex(model, context, {
+        return {
             ...base,
             thinking: {
                 enabled: true,
-                level: getGemini3ThinkingLevel(effort, geminiModel)
+                level: getGemini3ThinkingLevel(options.reasoning)
             }
-        });
+        };
     }
-    return streamGoogleVertex(model, context, {
-        ...base,
-        thinking: {
-            enabled: true,
-            budgetTokens: getGoogleBudget(geminiModel, effort)
-        }
-    });
-};
+    throw new Error(`No reasoning serialization is configured for Vertex model "${model.id}".`);
+}
 function createClient(model, project, location, optionsHeaders) {
     const httpOptions = {};
     if (model.headers || optionsHeaders) {
@@ -297,7 +301,10 @@ function buildParams(model, context, options = {}) {
     if (context.tools && context.tools.length > 0 && options.toolChoice) {
         config.toolConfig = {
             functionCallingConfig: {
-                mode: mapToolChoice(options.toolChoice)
+                ...(typeof options.toolChoice === 'object'
+                    ? { allowedFunctionNames: [options.toolChoice.name] }
+                    : {}),
+                mode: mapToolChoice(typeof options.toolChoice === 'object' ? 'any' : options.toolChoice)
             }
         };
     }
@@ -327,17 +334,40 @@ function buildParams(model, context, options = {}) {
     };
     return params;
 }
-function getGemini3ThinkingLevel(effort, model) {
-    if (isGemini3ProModelId(model.id)) {
-        switch (effort) {
-            case 'minimal':
-            case 'low':
-                return 'LOW';
-            case 'medium':
-            case 'high':
-                return 'HIGH';
-        }
-    }
+/** Serialize the provider-neutral request into the Vertex REST wire shape. */
+export function buildGoogleVertexRequest(model, context, options) {
+    const params = buildParams(model, context, resolveSimpleGoogleVertexOptions(model, options));
+    const config = { ...(params.config ?? {}) };
+    delete config.abortSignal;
+    const systemInstruction = config.systemInstruction;
+    const tools = config.tools;
+    const toolConfig = config.toolConfig;
+    const thinkingConfig = config.thinkingConfig;
+    delete config.systemInstruction;
+    delete config.tools;
+    delete config.toolConfig;
+    delete config.thinkingConfig;
+    if (thinkingConfig !== undefined)
+        config.thinkingConfig = thinkingConfig;
+    return {
+        contents: params.contents,
+        ...(typeof systemInstruction === 'string'
+            ? { systemInstruction: { parts: [{ text: systemInstruction }] } }
+            : systemInstruction
+                ? { systemInstruction }
+                : {}),
+        ...(tools ? { tools } : {}),
+        ...(toolConfig ? { toolConfig } : {}),
+        ...(Object.keys(config).length > 0 ? { generationConfig: config } : {})
+    };
+}
+/** Build the api-v2 Vertex-shaped endpoint used by CLI and embedded transports. */
+export function googleVertexGatewayEndpoint(baseUrl, modelId, operation) {
+    const normalized = baseUrl.replace(/\/+$/, '');
+    return (`${normalized}/v1/projects/-/locations/global/publishers/google/models/` +
+        `${encodeURIComponent(modelId)}:${operation}`);
+}
+function getGemini3ThinkingLevel(effort) {
     switch (effort) {
         case 'minimal':
             return 'MINIMAL';
@@ -347,27 +377,9 @@ function getGemini3ThinkingLevel(effort, model) {
             return 'MEDIUM';
         case 'high':
             return 'HIGH';
+        case 'xhigh':
+        case 'max':
+            throw new Error(`Gemini 3 does not support reasoning level "${effort}".`);
     }
 }
-function getGoogleBudget(model, effort) {
-    if (model.id.includes('2.5-pro')) {
-        const budgets = {
-            minimal: 128,
-            low: 2048,
-            medium: 8192,
-            high: 32768
-        };
-        return budgets[effort];
-    }
-    if (model.id.includes('2.5-flash')) {
-        const budgets = {
-            minimal: 128,
-            low: 2048,
-            medium: 8192,
-            high: 24576
-        };
-        return budgets[effort];
-    }
-    return -1;
-}
 //# sourceMappingURL=google-vertex.js.map

package/dist/ai/providers/google.js

@@ -1,10 +1,10 @@
 import { GoogleGenAI } from '@google/genai';
 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 { sanitizeSurrogates } from '../utils/sanitize-unicode.js';
 import { convertMessages, convertTools, isGemini3FlashModelId, isGemini3ProModelId, isThinkingPart, mapStopReason, mapToolChoice, retainThoughtSignature } from './google-shared.js';
-import { buildBaseOptions, clampReasoning } from './simple-options.js';
+import { buildBaseOptions } from './simple-options.js';
 // Counter for generating unique tool call IDs
 let toolCallCounter = 0;
 export const streamGoogle = (model, context, options) => {
@@ -224,30 +224,25 @@ export const streamSimpleGoogle = (model, context, options) => {
         throw new Error(`No API key for provider: ${model.provider}`);
     }
     const base = buildBaseOptions(model, options, apiKey);
-    if (!options?.reasoning) {
-        return streamGoogle(model, context, {
-            ...base,
-            thinking: { enabled: false }
-        });
+    if (options?.reasoning === undefined)
+        return streamGoogle(model, context, base);
+    if (!model.capabilities?.reasoning)
+        return streamGoogle(model, context, base);
+    assertModelSupportsReasoningLevel(model, options.reasoning);
+    if (options.reasoning === 'off') {
+        return streamGoogle(model, context, { ...base, thinking: { enabled: false } });
     }
-    const effort = clampReasoning(options.reasoning);
     const googleModel = model;
     if (isGemini3ProModelId(googleModel.id) || isGemini3FlashModelId(googleModel.id)) {
         return streamGoogle(model, context, {
             ...base,
             thinking: {
                 enabled: true,
-                level: getGemini3ThinkingLevel(effort, googleModel)
+                level: getGemini3ThinkingLevel(options.reasoning)
             }
         });
     }
-    return streamGoogle(model, context, {
-        ...base,
-        thinking: {
-            enabled: true,
-            budgetTokens: getGoogleBudget(googleModel, effort)
-        }
-    });
+    throw new Error(`No reasoning serialization is configured for Google model "${model.id}".`);
 };
 function createClient(model, apiKey, optionsHeaders) {
     const httpOptions = {};
@@ -311,17 +306,7 @@ function buildParams(model, context, options = {}) {
     };
     return params;
 }
-function getGemini3ThinkingLevel(effort, model) {
-    if (isGemini3ProModelId(model.id)) {
-        switch (effort) {
-            case 'minimal':
-            case 'low':
-                return 'LOW';
-            case 'medium':
-            case 'high':
-                return 'HIGH';
-        }
-    }
+function getGemini3ThinkingLevel(effort) {
     switch (effort) {
         case 'minimal':
             return 'MINIMAL';
@@ -331,27 +316,9 @@ function getGemini3ThinkingLevel(effort, model) {
             return 'MEDIUM';
         case 'high':
             return 'HIGH';
+        case 'xhigh':
+        case 'max':
+            throw new Error(`Gemini 3 does not support reasoning level "${effort}".`);
     }
 }
-function getGoogleBudget(model, effort) {
-    if (model.id.includes('2.5-pro')) {
-        const budgets = {
-            minimal: 128,
-            low: 2048,
-            medium: 8192,
-            high: 32768
-        };
-        return budgets[effort];
-    }
-    if (model.id.includes('2.5-flash')) {
-        const budgets = {
-            minimal: 128,
-            low: 2048,
-            medium: 8192,
-            high: 24576
-        };
-        return budgets[effort];
-    }
-    return -1;
-}
 //# sourceMappingURL=google.js.map

package/dist/ai/providers/openai-completions.d.ts

@@ -1,5 +1,6 @@
 import type { ChatCompletionMessageParam } from 'openai/resources/chat/completions.js';
 import type { Context, Model, OpenAICompletionsCompat, SimpleStreamOptions, StreamFunction, StreamOptions } from '../types.js';
+import { type OpenAIReasoningEffort } from './openai-reasoning.js';
 export interface OpenAICompletionsOptions extends StreamOptions {
     toolChoice?: 'auto' | 'none' | 'required' | {
         type: 'function';
@@ -7,9 +8,11 @@ export interface OpenAICompletionsOptions extends StreamOptions {
             name: string;
         };
     };
-    reasoningEffort?: 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
+    reasoningEffort?: OpenAIReasoningEffort;
 }
 export declare const streamOpenAICompletions: StreamFunction<'openai-completions', OpenAICompletionsOptions>;
 export declare const streamSimpleOpenAICompletions: StreamFunction<'openai-completions', SimpleStreamOptions>;
+/** Serialize one Chat Completions request for either streaming or invoke. */
+export declare function buildOpenAICompletionsRequest(model: Model<'openai-completions'>, context: Context, options: SimpleStreamOptions | undefined, stream: boolean): Record<string, unknown>;
 export declare function convertMessages(model: Model<'openai-completions'>, context: Context, compat: Required<OpenAICompletionsCompat>): ChatCompletionMessageParam[];
 //# sourceMappingURL=openai-completions.d.ts.map

package/dist/ai/providers/openai-completions.js

@@ -1,11 +1,12 @@
 import OpenAI from 'openai';
 import { getEnvApiKey } from '../env-api-keys.js';
-import { calculateCost, supportsXhigh } from '../models.js';
+import { 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';
+import { resolveOpenAIReasoningEffort } from './openai-reasoning.js';
 import { applyNormalizedProviderError } from './provider-error-normalization.js';
-import { buildBaseOptions, clampReasoning } from './simple-options.js';
+import { buildBaseOptions } from './simple-options.js';
 import { transformMessages } from './transform-messages.js';
 /**
  * Normalize tool call ID for Mistral.
@@ -278,17 +279,23 @@ export const streamSimpleOpenAICompletions = (model, context, options) => {
     if (!apiKey) {
         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 toolChoice = options?.toolChoice;
     return streamOpenAICompletions(model, context, {
-        ...base,
-        reasoningEffort,
-        toolChoice
+        ...resolveSimpleOpenAICompletionsOptions(model, options),
+        apiKey
     });
 };
+function mapToolChoice(toolChoice) {
+    if (!toolChoice || typeof toolChoice === 'string')
+        return toolChoice;
+    return { function: { name: toolChoice.name }, type: 'function' };
+}
+function resolveSimpleOpenAICompletionsOptions(model, options) {
+    return {
+        ...buildBaseOptions(model, options, options?.apiKey),
+        reasoningEffort: resolveOpenAIReasoningEffort(model, options?.reasoning),
+        toolChoice: mapToolChoice(options?.toolChoice)
+    };
+}
 function createClient(model, context, apiKey, optionsHeaders, fetchOptions, fetchImpl) {
     if (!apiKey) {
         if (!process.env.OPENAI_API_KEY) {
@@ -371,6 +378,15 @@ function buildParams(model, context, options) {
     }
     return params;
 }
+/** Serialize one Chat Completions request for either streaming or invoke. */
+export function buildOpenAICompletionsRequest(model, context, options, stream) {
+    const params = buildParams(model, context, resolveSimpleOpenAICompletionsOptions(model, options));
+    const body = { ...params };
+    body.stream = stream;
+    if (!stream)
+        delete body.stream_options;
+    return body;
+}
 function maybeAddOpenRouterAnthropicCacheControl(model, messages) {
     if (model.provider !== 'openrouter' || !model.id.startsWith('anthropic/'))
         return;

package/dist/ai/providers/openai-reasoning.d.ts

@@ -0,0 +1,5 @@
+import type { Api, Model, ReasoningLevel } from '../types.js';
+export type OpenAIReasoningEffort = 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+/** Preserve exact native effort names; explicit `off` maps to OpenAI `none`. */
+export declare function resolveOpenAIReasoningEffort(model: Model<Api>, level: ReasoningLevel | undefined): OpenAIReasoningEffort | undefined;
+//# sourceMappingURL=openai-reasoning.d.ts.map

package/dist/ai/providers/openai-reasoning.js

@@ -0,0 +1,13 @@
+import { assertModelSupportsReasoningLevel } from '../models.js';
+/** Preserve exact native effort names; explicit `off` maps to OpenAI `none`. */
+export function resolveOpenAIReasoningEffort(model, level) {
+    if (level === undefined)
+        return undefined;
+    // Unclassified custom/third-party models use their provider default. A
+    // configurable wire value requires an explicit model capability contract.
+    if (!model.capabilities?.reasoning)
+        return undefined;
+    assertModelSupportsReasoningLevel(model, level);
+    return level === 'off' ? 'none' : level;
+}
+//# sourceMappingURL=openai-reasoning.js.map

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

@@ -85,7 +85,7 @@ function convertUserInputContent(item) {
         return {
             type: 'input_file',
             file_data: `data:${item.mimeType};base64,${item.data}`,
-            filename: item.filename ?? 'document'
+            filename: item.filename ?? 'document.pdf'
         };
     }
     return {

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

@@ -1,14 +1,18 @@
 import type { ResponseCreateParamsStreaming } from 'openai/resources/responses/responses.js';
-import type { SimpleStreamOptions, StreamFunction, StreamOptions } from '../types.js';
+import type { Context, Model, SimpleStreamOptions, StreamFunction, StreamOptions } from '../types.js';
+import { type OpenAIReasoningEffort } from './openai-reasoning.js';
 export interface OpenAIResponsesOptions extends StreamOptions {
-    reasoningEffort?: 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
+    reasoningEffort?: OpenAIReasoningEffort;
     reasoningSummary?: 'auto' | 'detailed' | 'concise' | null;
     serviceTier?: ResponseCreateParamsStreaming['service_tier'];
+    toolChoice?: ResponseCreateParamsStreaming['tool_choice'];
 }
 /**
  * Generate function for OpenAI Responses API
  */
 export declare const streamOpenAIResponses: StreamFunction<'openai-responses', OpenAIResponsesOptions>;
 export declare const streamSimpleOpenAIResponses: StreamFunction<'openai-responses', SimpleStreamOptions>;
+/** Serialize one Responses API request for either streaming or invoke. */
+export declare function buildOpenAIResponsesRequest(model: Model<'openai-responses'>, context: Context, options: SimpleStreamOptions | undefined, stream: boolean): Record<string, unknown>;
 export declare function getServiceTierCostMultiplier(serviceTier: ResponseCreateParamsStreaming['service_tier'] | undefined): number;
 //# sourceMappingURL=openai-responses.d.ts.map

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

@@ -1,10 +1,10 @@
 import OpenAI 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 { applyNormalizedProviderError } from './provider-error-normalization.js';
-import { buildBaseOptions, clampReasoning } from './simple-options.js';
+import { buildBaseOptions } from './simple-options.js';
 const OPENAI_TOOL_CALL_PROVIDERS = new Set(['openai', 'opencode']);
 /**
  * Resolve cache retention preference.
@@ -93,17 +93,26 @@ export const streamSimpleOpenAIResponses = (model, context, options) => {
     if (!apiKey) {
         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 serviceTier = options?.serviceTier;
     return streamOpenAIResponses(model, context, {
-        ...base,
-        reasoningEffort,
+        ...resolveSimpleOpenAIResponsesOptions(model, options),
+        apiKey,
         serviceTier
     });
 };
+function mapToolChoice(toolChoice) {
+    if (!toolChoice || typeof toolChoice === 'string')
+        return toolChoice;
+    return { name: toolChoice.name, type: 'function' };
+}
+function resolveSimpleOpenAIResponsesOptions(model, options) {
+    return {
+        ...buildBaseOptions(model, options, options?.apiKey),
+        reasoningEffort: resolveOpenAIReasoningEffort(model, options?.reasoning),
+        serviceTier: options?.serviceTier,
+        toolChoice: mapToolChoice(options?.toolChoice)
+    };
+}
 function createClient(model, context, apiKey, optionsHeaders, fetchOptions, fetchImpl) {
     if (!apiKey) {
         if (!process.env.OPENAI_API_KEY) {
@@ -147,31 +156,27 @@ function buildParams(model, context, options) {
     if (context.tools) {
         params.tools = convertResponsesTools(context.tools);
     }
+    if (options?.toolChoice) {
+        params.tool_choice = options.toolChoice;
+    }
     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.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;
 }
+/** Serialize one Responses API request for either streaming or invoke. */
+export function buildOpenAIResponsesRequest(model, context, options, stream) {
+    return {
+        ...buildParams(model, context, resolveSimpleOpenAIResponsesOptions(model, options)),
+        stream
+    };
+}
 export function getServiceTierCostMultiplier(serviceTier) {
     switch (serviceTier) {
         case 'flex':

package/dist/ai/providers/simple-options.d.ts

@@ -1,7 +1,6 @@
-import type { Api, Model, SimpleStreamOptions, StreamOptions, ThinkingLevel } from '../types.js';
+import type { Api, EnabledReasoningLevel, Model, SimpleStreamOptions, StreamOptions } from '../types.js';
 export declare function buildBaseOptions(model: Model<Api>, options?: SimpleStreamOptions, apiKey?: string): StreamOptions;
-export declare function clampReasoning(effort: ThinkingLevel | undefined): Exclude<ThinkingLevel, 'xhigh'> | undefined;
-export declare function adjustMaxTokensForThinking(baseMaxTokens: number, modelMaxTokens: number, reasoningLevel: ThinkingLevel): {
+export declare function adjustMaxTokensForThinking(baseMaxTokens: number, modelMaxTokens: number, reasoningLevel: EnabledReasoningLevel): {
     maxTokens: number;
     thinkingBudget: number;
 };

package/dist/ai/providers/simple-options.js

@@ -14,19 +14,17 @@ export function buildBaseOptions(model, options, apiKey) {
         metadata: options?.metadata
     };
 }
-export function clampReasoning(effort) {
-    return effort === 'xhigh' ? 'high' : effort;
-}
 export function adjustMaxTokensForThinking(baseMaxTokens, modelMaxTokens, reasoningLevel) {
     const budgets = {
         minimal: 1024,
         low: 2048,
         medium: 8192,
-        high: 16384
+        high: 16384,
+        xhigh: 32768,
+        max: 49152
     };
     const minOutputTokens = 1024;
-    const level = clampReasoning(reasoningLevel);
-    let thinkingBudget = budgets[level];
+    let thinkingBudget = budgets[reasoningLevel];
     const maxTokens = Math.min(baseMaxTokens + thinkingBudget, modelMaxTokens);
     if (maxTokens <= thinkingBudget) {
         thinkingBudget = Math.max(0, maxTokens - minOutputTokens);

package/dist/ai/types.d.ts

@@ -4,7 +4,22 @@ export type KnownApi = 'openai-completions' | 'openai-responses' | 'azure-openai
 export type Api = KnownApi | (string & {});
 export type KnownProvider = 'anthropic' | 'google' | 'google-vertex' | 'xai' | 'groq' | 'cerebras' | 'openrouter' | 'vercel-ai-gateway' | 'zai' | 'minimax' | 'minimax-cn' | 'huggingface' | 'opencode' | 'kimi-coding';
 export type Provider = KnownProvider | string;
-export type ThinkingLevel = 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
+/** Product-level reasoning selection. Absence means "use the provider/model default". */
+export type ReasoningLevel = 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+export type EnabledReasoningLevel = Exclude<ReasoningLevel, 'off'>;
+/** Provider-neutral tool selection policy. Providers own the wire-format mapping. */
+export type ToolChoice = 'auto' | 'none' | 'required' | {
+    readonly name: string;
+};
+export interface ModelCapabilities {
+    /** Exact reasoning controls exposed by this model. */
+    readonly reasoning?: {
+        readonly control: 'adaptive-effort' | 'effort' | 'thinking-level' | 'budget' | 'fixed';
+        readonly levels: readonly EnabledReasoningLevel[];
+        readonly defaultLevel: EnabledReasoningLevel;
+        readonly supportsOff: boolean;
+    };
+}
 export type CacheRetention = 'none' | 'short' | 'long';
 export type Transport = 'sse' | 'websocket' | 'auto';
 export interface StreamOptions {
@@ -64,7 +79,8 @@ export interface StreamOptions {
 }
 export type ProviderStreamOptions = StreamOptions & Record<string, unknown>;
 export interface SimpleStreamOptions extends StreamOptions {
-    reasoning?: ThinkingLevel;
+    reasoning?: ReasoningLevel;
+    toolChoice?: ToolChoice;
 }
 export type StreamFunction<TApi extends Api = Api, TOptions extends StreamOptions = StreamOptions> = (model: Model<TApi>, context: Context, options?: TOptions) => AssistantMessageEventStream;
 export type StreamFn = StreamFunction;
@@ -281,6 +297,7 @@ export interface Model<TApi extends Api> {
     };
     contextWindow: number;
     maxTokens: number;
+    capabilities?: ModelCapabilities;
     headers?: Record<string, string>;
     /** Compatibility overrides for OpenAI-compatible APIs. If not set, auto-detected from baseUrl. */
     compat?: TApi extends 'openai-completions' ? OpenAICompletionsCompat : never;

package/dist/app/agent-session-runtime-adapter.js

@@ -7,11 +7,12 @@
  * only exposes a subset of methods and resolves model/thinking-level
  * defaults consistently with how the CLI bootstrapped sessions previously.
  */
+import { resolveModelReasoningLevel } from '../ai/models.js';
 import { completeSimple, streamSimple } from '../ai/stream.js';
 import { AgentStopReason } from '../contracts/agent-snapshot.js';
 import { createAgentSnapshotFromAgentMessages } from '../core/agent-snapshot-builder.js';
 import { createEmbeddedAgentRuntime } from '../core/embedded-agent-facade.js';
-import { AgentController, AgentEngine, DEFAULT_THINKING_LEVEL } from '../core/index.js';
+import { AgentController, AgentEngine } from '../core/index.js';
 import { createPendingHostToolRequests } from '../core/pending-host-tool-requests.js';
 import { getHostToolTimeoutMs } from '../embedded-agent/host-tools/timeouts.js';
 import { AgentSession, LoginRequiredError } from './agent-session.js';
@@ -121,14 +122,14 @@ export async function createAgentSessionRuntimeAdapter(options) {
     if (thinkingLevel === undefined && hasExistingSession) {
         thinkingLevel = hasThinkingEntry
             ? existingSession.thinkingLevel
-            : (settingsManager.getDefaultThinkingLevel() ?? DEFAULT_THINKING_LEVEL);
+            : settingsManager.getDefaultThinkingLevel();
     }
     if (thinkingLevel === undefined) {
-        thinkingLevel = settingsManager.getDefaultThinkingLevel() ?? DEFAULT_THINKING_LEVEL;
-    }
-    if (!model || !model.reasoning) {
-        thinkingLevel = 'off';
+        thinkingLevel = settingsManager.getDefaultThinkingLevel();
     }
+    thinkingLevel = model
+        ? resolveModelReasoningLevel(model, thinkingLevel)
+        : 'off';
     // Mutable holder so the AgentEngine constructor's `getApiKey` can resolve
     // off the agent that we'll build below. Lets us construct the runtime (and
     // pending host-tool requests that depend on its heartbeat) before the

package/dist/app/agent-session.d.ts

@@ -170,10 +170,7 @@ export declare class AgentSession {
     /** Details from the last prePromptContext call (e.g. { workbooks: string[] }). Read by TUI for annotations. */
     lastPrePromptDetails?: unknown;
     private readonly _sessionState;
-    private _collabClient;
     private _sheetPool;
-    private _collabAwareness;
-    private _collabSync;
     private _modelRegistry;
     /** Fire-and-forget tool-call summary generation. */
     private _summaryEmitter;
@@ -419,22 +416,10 @@ export declare class AgentSession {
     getFollowUpMessages(): readonly string[];
     /** Resource loader for skills, prompts, and context files used by this session. */
     get resourceLoader(): RuntimeResourceLoader;
-    /** Active collaboration client when the session is part of a collab room, otherwise null. */
-    get collabClient(): import('./collab/collab-client.js').CollabClient | null;
-    /** Attach or detach the collaboration client for this session. */
-    set collabClient(client: import('./collab/collab-client.js').CollabClient | null);
     /** Sheet-engine pool currently bound to this session, or null if unbound. */
     get sheetPool(): import('@shortcut/mog-sandbox-runtime').SheetEnginePool | null;
     /** Attach or detach the sheet-engine pool used by new-sheet flows. */
     set sheetPool(pool: import('@shortcut/mog-sandbox-runtime').SheetEnginePool | null);
-    /** Awareness layer for the active collab session (peer cursors, presence), or null. */
-    get collabAwareness(): import('./collab/awareness.js').CollabAwareness | null;
-    /** Attach or detach the collab awareness layer. */
-    set collabAwareness(awareness: import('./collab/awareness.js').CollabAwareness | null);
-    /** Collab document sync controller for this session, or null if not in a room. */
-    get collabSync(): import('./collab/collab-sync.js').CollabSync | null;
-    /** Attach or detach the collab document sync controller. */
-    set collabSync(sync: import('./collab/collab-sync.js').CollabSync | null);
     /**
      * Abort current operation and wait for agent to become idle.
      */