shortcutxl 0.3.69 → 0.3.70

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## [0.3.70]
+
+- **GPT-5.6 Sol default** - ShortcutXL now defaults CLI and embedded sessions to GPT-5.6 Sol and shows clearer compact model labels.
+- **Path-based attachments** - Fixed CLI file attachments that reference files by path.
+
 ## [0.3.69]
 
 - **CLI screenshot capture** - ShortcutXL can now capture screenshots from CLI sessions, giving agents visual context when working with Excel or the desktop.

package/agent-docs/docs/providers.md

@@ -101,7 +101,7 @@ export AZURE_OPENAI_RESOURCE_NAME=your-resource
 
 # Optional
 export AZURE_OPENAI_API_VERSION=2024-02-01
-export AZURE_OPENAI_DEPLOYMENT_NAME_MAP=gpt-5.5-2026-04-23=my-gpt55
+export AZURE_OPENAI_DEPLOYMENT_NAME_MAP=<openai-model-id>=my-openai-deployment
 ```
 
 ### Amazon Bedrock

package/agent-docs/docs/rpc.md

@@ -302,7 +302,7 @@ Set the reasoning/thinking level for models that support it.
 
 Levels: `"off"`, `"minimal"`, `"low"`, `"medium"`, `"high"`, `"xhigh"`
 
-Note: `"xhigh"` is only supported by the GPT 5.5 and Claude Opus 4.8 model families.
+Note: `"xhigh"` is only supported by the OpenAI reasoning and Claude Opus 4.8 model families.
 
 Response:
 

package/agent-docs/docs/session.md

@@ -212,7 +212,7 @@ A message in the conversation. The `message` field contains an `AgentMessage`.
 Emitted when the user switches models mid-session.
 
 ```json
-{"type":"model_change","id":"d4e5f6g7","parentId":"c3d4e5f6","timestamp":"2024-12-03T14:05:00.000Z","provider":"openai","modelId":"gpt-5.5-2026-04-23"}
+{"type":"model_change","id":"d4e5f6g7","parentId":"c3d4e5f6","timestamp":"2024-12-03T14:05:00.000Z","provider":"openai","modelId":"openai-reasoning-model"}
 ```
 
 ### ThinkingLevelChangeEntry

package/agent-docs/examples/extensions/custom-provider-gitlab-duo/index.ts

@@ -30,6 +30,7 @@ const GITLAB_COM_URL = 'https://gitlab.com';
 const AI_GATEWAY_URL = 'https://cloud.gitlab.com';
 const ANTHROPIC_PROXY_URL = `${AI_GATEWAY_URL}/ai/v1/proxy/anthropic/`;
 const OPENAI_PROXY_URL = `${AI_GATEWAY_URL}/ai/v1/proxy/openai/v1`;
+const OPENAI_REASONING_MODEL_ID = 'gpt-5.6-sol';
 
 const BUNDLED_CLIENT_ID = 'da4edff2e6ebd2bc3208611e2768bc1c1dd7be791dc5ff26ca34ca9ee44f7d4b';
 const OAUTH_SCOPES = ['.shortcut'];
@@ -91,15 +92,15 @@ export const MODELS: GitLabModel[] = [
   },
   // OpenAI (all use Responses API)
   {
-    id: 'gpt-5.5-2026-04-23',
-    name: 'GPT 5.5',
+    id: OPENAI_REASONING_MODEL_ID,
+    name: 'GPT 5.6 Sol',
     backend: 'openai',
     baseUrl: OPENAI_PROXY_URL,
     reasoning: true,
     input: ['text', 'image'],
-    cost: { input: 2.5, output: 10, cacheRead: 0, cacheWrite: 0 },
-    contextWindow: 128000,
-    maxTokens: 16384
+    cost: { input: 5, output: 30, cacheRead: 0.5, cacheWrite: 6.25 },
+    contextWindow: 1000000,
+    maxTokens: 128000
   }
 ];
 

package/agent-docs/examples/extensions/custom-provider-gitlab-duo/test.ts

@@ -4,7 +4,7 @@
  *
  * Examples:
  *   pnpm exec tsx test.ts                              # Test default (claude-sonnet-5)
- *   pnpm exec tsx test.ts gpt-5.5-2026-04-23           # Test GPT 5.5
+ *   pnpm exec tsx test.ts <openai-model-id>             # Test an OpenAI model
  *   pnpm exec tsx test.ts claude-sonnet-5 --thinking
  */
 

package/agent-docs/examples/extensions/summarize.ts

@@ -3,6 +3,9 @@ import type { ExtensionAPI, ExtensionCommandContext } from 'shortcutxl/app';
 import { DynamicBorder, getMarkdownTheme } from 'shortcutxl/shell';
 import { Container, Markdown, matchesKey, Text } from 'shortcutxl/tui';
 
+const OPENAI_SUMMARY_MODEL_ID = 'gpt-5.6-sol';
+const OPENAI_SUMMARY_MODEL_REF = `openai/${OPENAI_SUMMARY_MODEL_ID}`;
+
 type ContentBlock = {
   type?: string;
   text?: string;
@@ -160,14 +163,14 @@ export default function (shortcut: ExtensionAPI) {
         ctx.ui.notify('Preparing summary...', 'info');
       }
 
-      const model = getModel('openai', 'gpt-5.5-2026-04-23');
+      const model = getModel('openai', OPENAI_SUMMARY_MODEL_ID);
       if (!model && ctx.hasUI) {
-        ctx.ui.notify('Model openai/gpt-5.5-2026-04-23 not found', 'warning');
+        ctx.ui.notify(`Model ${OPENAI_SUMMARY_MODEL_REF} not found`, 'warning');
       }
 
       const apiKey = model ? await ctx.modelRegistry.getApiKey(model) : undefined;
       if (!apiKey && ctx.hasUI) {
-        ctx.ui.notify('No API key for openai/gpt-5.5-2026-04-23', 'warning');
+        ctx.ui.notify(`No API key for ${OPENAI_SUMMARY_MODEL_REF}`, 'warning');
       }
 
       if (!model || !apiKey) {

package/dist/ai/models.d.ts

@@ -11,7 +11,7 @@ export declare function calculateCost<TApi extends Api>(model: Model<TApi>, usag
  * Check if a model supports xhigh thinking level.
  *
  * Supported today:
- * - GPT-5.5 model family
+ * - Shortcut's current and legacy OpenAI reasoning models
  * - Anthropic Messages API Opus 4.8 models (xhigh maps to adaptive effort "max")
  */
 export declare function supportsXhigh<TApi extends Api>(model: Model<TApi>): boolean;

package/dist/ai/models.js

@@ -1,3 +1,4 @@
+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
@@ -35,11 +36,12 @@ export function calculateCost(model, usage) {
  * Check if a model supports xhigh thinking level.
  *
  * Supported today:
- * - GPT-5.5 model family
+ * - Shortcut's current and legacy OpenAI reasoning models
  * - Anthropic Messages API Opus 4.8 models (xhigh maps to adaptive effort "max")
  */
 export function supportsXhigh(model) {
-    if (model.id.includes('gpt-5.5')) {
+    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') {

package/dist/ai/providers/anthropic.js

@@ -85,11 +85,43 @@ function convertContentBlocks(content) {
 }
 function mergeHeaders(...headerSources) {
     const merged = {};
+    const betaHeaderName = 'anthropic-beta';
+    const betaTokens = [];
+    const seenBetaTokens = new Set();
+    const addBetaTokens = (value) => {
+        for (const token of value.split(',')) {
+            const trimmed = token.trim();
+            if (!trimmed)
+                continue;
+            const key = trimmed.toLowerCase();
+            if (seenBetaTokens.has(key))
+                continue;
+            seenBetaTokens.add(key);
+            betaTokens.push(trimmed);
+        }
+    };
     for (const headers of headerSources) {
         if (headers) {
-            Object.assign(merged, headers);
+            for (const [key, value] of Object.entries(headers)) {
+                if (key.toLowerCase() === betaHeaderName) {
+                    delete merged[key];
+                    if (typeof value === 'string') {
+                        addBetaTokens(value);
+                    }
+                    else {
+                        betaTokens.length = 0;
+                        seenBetaTokens.clear();
+                        merged[betaHeaderName] = value;
+                    }
+                    continue;
+                }
+                merged[key] = value;
+            }
         }
     }
+    if (betaTokens.length > 0) {
+        merged[betaHeaderName] = betaTokens.join(',');
+    }
     return merged;
 }
 export const streamAnthropic = (model, context, options) => {
@@ -444,7 +476,7 @@ function buildParams(model, context, options) {
     if (options?.thinkingEnabled && model.reasoning) {
         if (supportsAdaptiveThinking(model.id)) {
             // Adaptive thinking: Claude decides when and how much to think
-            params.thinking = { type: 'adaptive' };
+            params.thinking = { type: 'adaptive', display: 'summarized' };
             if (options.effort) {
                 params.output_config = { effort: options.effort };
             }

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

@@ -3,7 +3,7 @@ import type { Api, AssistantMessage, Context, Model, Tool, Usage } from '../type
 import type { AssistantMessageEventStream } from '../utils/event-stream.js';
 export interface OpenAIResponsesStreamOptions {
     serviceTier?: ResponseCreateParamsStreaming['service_tier'];
-    applyServiceTierPricing?: (usage: Usage, serviceTier: ResponseCreateParamsStreaming['service_tier'] | undefined, model: Pick<Model<Api>, 'id'>) => void;
+    applyServiceTierPricing?: (usage: Usage, serviceTier: ResponseCreateParamsStreaming['service_tier'] | undefined) => void;
 }
 export interface ConvertResponsesMessagesOptions {
     includeSystemPrompt?: boolean;

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

@@ -1,3 +1,4 @@
+import { safeModelStreamErrorMessage } from '../../contracts/model-stream.js';
 import { calculateCost } from '../models.js';
 import { parseStreamingJson } from '../utils/json-parse.js';
 import { sanitizeSurrogates } from '../utils/sanitize-unicode.js';
@@ -5,6 +6,46 @@ import { transformMessages } from './transform-messages.js';
 // =============================================================================
 // Utilities
 // =============================================================================
+class OpenAIResponsesStreamError extends Error {
+    details;
+    constructor(details) {
+        super(safeModelStreamErrorMessage(details));
+        this.name = 'OpenAIResponsesStreamError';
+        this.details = details;
+    }
+}
+function isOpenAIResponsesInvalidRequestCode(code) {
+    return (code?.startsWith('invalid_') === true ||
+        code === 'empty_image_file' ||
+        code === 'failed_to_download_image' ||
+        code === 'image_content_policy_violation' ||
+        code === 'image_file_not_found' ||
+        code === 'image_parse_error' ||
+        code === 'image_too_large' ||
+        code === 'image_too_small' ||
+        code === 'unsupported_image_media_type');
+}
+function openAIResponsesStreamErrorDetails(error) {
+    const code = error?.code?.trim() || undefined;
+    if (code === 'rate_limit_exceeded') {
+        return { code, providerErrorType: 'rate_limit', retryable: true, status: 429 };
+    }
+    if (code === 'server_error' || code === 'vector_store_timeout') {
+        return {
+            ...(code ? { code } : {}),
+            providerErrorType: 'internal',
+            retryable: true,
+            status: 503
+        };
+    }
+    if (isOpenAIResponsesInvalidRequestCode(code)) {
+        return { code, providerErrorType: 'invalid_request', retryable: false, status: 400 };
+    }
+    return { ...(code ? { code } : {}), providerErrorType: 'internal', retryable: true, status: 503 };
+}
+function throwOpenAIResponsesStreamError(error) {
+    throw new OpenAIResponsesStreamError(openAIResponsesStreamErrorDetails(error));
+}
 /** Fast deterministic hash to shorten long strings */
 function shortHash(str) {
     let h1 = 0xdeadbeef;
@@ -18,6 +59,18 @@ function shortHash(str) {
     h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507) ^ Math.imul(h1 ^ (h1 >>> 13), 3266489909);
     return (h2 >>> 0).toString(36) + (h1 >>> 0).toString(36);
 }
+function readNumericTokenDetail(details, keys) {
+    if (!details || typeof details !== 'object')
+        return 0;
+    const record = details;
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === 'number' && Number.isFinite(value)) {
+            return value;
+        }
+    }
+    return 0;
+}
 // =============================================================================
 // Message conversion
 // =============================================================================
@@ -383,14 +436,21 @@ export async function processResponsesStream(openaiStream, output, stream, model
         else if (event.type === 'response.completed') {
             const response = event.response;
             if (response?.usage) {
-                const cachedTokens = response.usage.input_tokens_details?.cached_tokens || 0;
+                const inputDetails = response.usage.input_tokens_details;
+                const cachedTokens = readNumericTokenDetail(inputDetails, ['cached_tokens']);
+                const cacheWriteTokens = readNumericTokenDetail(inputDetails, [
+                    'cache_write_tokens',
+                    'cache_creation_tokens',
+                    'cache_write_input_tokens',
+                    'cache_creation_input_tokens'
+                ]);
                 output.usage = {
                     // OpenAI includes cached tokens in input_tokens; cost calculation
                     // derives uncached input from input - cacheRead - cacheWrite.
                     input: response.usage.input_tokens || 0,
                     output: response.usage.output_tokens || 0,
                     cacheRead: cachedTokens,
-                    cacheWrite: 0,
+                    cacheWrite: cacheWriteTokens,
                     totalTokens: response.usage.total_tokens || 0,
                     cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
                 };
@@ -398,7 +458,7 @@ export async function processResponsesStream(openaiStream, output, stream, model
             calculateCost(model, output.usage);
             if (options?.applyServiceTierPricing) {
                 const serviceTier = response?.service_tier ?? options.serviceTier;
-                options.applyServiceTierPricing(output.usage, serviceTier, model);
+                options.applyServiceTierPricing(output.usage, serviceTier);
             }
             // Map status to stop reason
             output.stopReason = mapStopReason(response?.status);
@@ -407,10 +467,13 @@ export async function processResponsesStream(openaiStream, output, stream, model
             }
         }
         else if (event.type === 'error') {
-            throw new Error(`Error Code ${event.code}: ${event.message}` || 'Unknown error');
+            throwOpenAIResponsesStreamError({
+                code: event.code,
+                message: event.message
+            });
         }
         else if (event.type === 'response.failed') {
-            throw new Error('Unknown error');
+            throwOpenAIResponsesStreamError(event.response.error);
         }
     }
 }

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

@@ -1,5 +1,5 @@
 import type { ResponseCreateParamsStreaming } from 'openai/resources/responses/responses.js';
-import type { Api, Model, SimpleStreamOptions, StreamFunction, StreamOptions } from '../types.js';
+import type { SimpleStreamOptions, StreamFunction, StreamOptions } from '../types.js';
 export interface OpenAIResponsesOptions extends StreamOptions {
     reasoningEffort?: 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
     reasoningSummary?: 'auto' | 'detailed' | 'concise' | null;
@@ -10,5 +10,5 @@ export interface OpenAIResponsesOptions extends StreamOptions {
  */
 export declare const streamOpenAIResponses: StreamFunction<'openai-responses', OpenAIResponsesOptions>;
 export declare const streamSimpleOpenAIResponses: StreamFunction<'openai-responses', SimpleStreamOptions>;
-export declare function getServiceTierCostMultiplier(serviceTier: ResponseCreateParamsStreaming['service_tier'] | undefined, model: Pick<Model<Api>, 'id'>): number;
+export declare function getServiceTierCostMultiplier(serviceTier: ResponseCreateParamsStreaming['service_tier'] | undefined): number;
 //# sourceMappingURL=openai-responses.d.ts.map

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

@@ -1,5 +1,4 @@
 import OpenAI from 'openai';
-import { SHORTCUT_MODEL_ID } from '../../model-ids.js';
 import { getEnvApiKey } from '../env-api-keys.js';
 import { supportsXhigh } from '../models.js';
 import { AssistantMessageEventStream } from '../utils/event-stream.js';
@@ -98,9 +97,11 @@ export const streamSimpleOpenAIResponses = (model, context, options) => {
     const reasoningEffort = supportsXhigh(model)
         ? options?.reasoning
         : clampReasoning(options?.reasoning);
+    const serviceTier = options?.serviceTier;
     return streamOpenAIResponses(model, context, {
         ...base,
-        reasoningEffort
+        reasoningEffort,
+        serviceTier
     });
 };
 function createClient(model, context, apiKey, optionsHeaders, fetchOptions) {
@@ -170,20 +171,18 @@ function buildParams(model, context, options) {
     }
     return params;
 }
-export function getServiceTierCostMultiplier(serviceTier, model) {
+export function getServiceTierCostMultiplier(serviceTier) {
     switch (serviceTier) {
         case 'flex':
             return 0.5;
         case 'priority':
-            if (model.id === SHORTCUT_MODEL_ID.Gpt55)
-                return 2.5;
             return 2;
         default:
             return 1;
     }
 }
-function applyServiceTierPricing(usage, serviceTier, model) {
-    const multiplier = getServiceTierCostMultiplier(serviceTier, model);
+function applyServiceTierPricing(usage, serviceTier) {
+    const multiplier = getServiceTierCostMultiplier(serviceTier);
     if (multiplier === 1)
         return;
     usage.cost.input *= multiplier;

package/dist/ai/providers/provider-error-normalization.js

@@ -1,4 +1,4 @@
-import { LLMErrorMetadataHeaders, parseStreamErrorPayload, safeModelStreamErrorMessage } from '../../contracts/model-stream.js';
+import { applyModelAccessDeniedErrorDetails, isShortcutXLModelStreamErrorDetails, LLMErrorMetadataHeaders, parseStreamErrorPayload, safeModelStreamErrorMessage } from '../../contracts/model-stream.js';
 import { isContextOverflowErrorMessage } from '../utils/overflow.js';
 function getErrorMessage(error) {
     return error instanceof Error ? error.message : (JSON.stringify(error) ?? String(error));
@@ -30,14 +30,24 @@ function normalizeApiV2ErrorDetails(error, rawMessage) {
     const details = parseStreamErrorPayload(payload, status) ?? (status ? { status } : undefined);
     if (!details)
         return undefined;
+    const accessAwareDetails = applyModelAccessDeniedErrorDetails(details, rawMessage);
     if (isContextOverflowErrorMessage(rawMessage)) {
-        return { ...details, code: 'context_overflow' };
+        return { ...accessAwareDetails, code: 'context_overflow' };
     }
-    return details;
+    return accessAwareDetails;
+}
+function streamDetailsFromError(error) {
+    const detailsError = error;
+    if (isShortcutXLModelStreamErrorDetails(detailsError.details))
+        return detailsError.details;
+    if (isShortcutXLModelStreamErrorDetails(detailsError.errorDetails))
+        return detailsError.errorDetails;
+    return undefined;
 }
 export function applyNormalizedProviderError(output, error) {
     const rawMessage = getErrorMessage(error);
-    const details = normalizeApiV2ErrorDetails(error, rawMessage);
+    const details = streamDetailsFromError(error) ??
+        normalizeApiV2ErrorDetails(error, rawMessage);
     if (!details) {
         output.errorMessage = rawMessage;
         return { usedStructuredDetails: false };

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

@@ -129,7 +129,9 @@ export interface AgentSessionConfig {
         info?: (input: {
             module: string;
             event: string;
+            analyticsEvent?: boolean;
             data?: Record<string, unknown>;
+            duration?: number;
         }) => void;
     };
 }
@@ -187,6 +189,7 @@ export declare class AgentSession {
     private _summaryEmitter;
     private _toolSummaryDiagnostics;
     private _observability?;
+    private _nextCompactionOpId;
     private _tools;
     private _models;
     private _fastModeAllowed;
@@ -481,8 +484,8 @@ export declare class AgentSession {
     supportsXhighThinking(): boolean;
     /** True if the active model exposes any thinking/reasoning configuration. */
     supportsThinking(): boolean;
-    /** Check compaction decision and trigger if needed. */
     private _triggerCompactionIfNeeded;
+    private _createCompactionObservabilityWrap;
     /** Run a manual compaction pass over the conversation, optionally with custom instructions. */
     compact(customInstructions?: string): Promise<CompactionResult>;
     /** Cancel any in-flight compaction run. */

package/dist/app/agent-session.js

@@ -27,6 +27,7 @@ import { expandPromptTemplate } from './resources/prompt-template-expansion.js';
 import { AUTONOMOUS_STATE_CUSTOM_TYPE, buildAutonomousRefreshPrompt, extractProgressFolder, inferAutonomousStateFromEntries } from './session/autonomous-workflow.js';
 import { BranchManager } from './session/branch-manager.js';
 import { parseBudgetCommand } from './session/budget-command.js';
+import { createCompactionObservabilityWrap } from './session/compaction-observability.js';
 import { emitExtensionEvent } from './session/extension-emitter.js';
 import { ExtensionLifecycle } from './session/extension-lifecycle.js';
 import { ModelManager } from './session/model-manager.js';
@@ -114,6 +115,7 @@ export class AgentSession {
     _summaryEmitter;
     _toolSummaryDiagnostics = [];
     _observability;
+    _nextCompactionOpId = 0;
     // Tool registry — owns tool maps, prompt snippets, system prompt rebuild
     _tools;
     // Model manager — model switching, cycling, thinking level
@@ -1378,15 +1380,18 @@ export class AgentSession {
     supportsThinking() {
         return supportsThinking(this.model);
     }
-    // =========================================================================
-    // Compaction (delegated to SessionCompaction)
-    // =========================================================================
-    // =========================================================================
     // Compaction (delegated to SessionCompaction + bridge factories)
-    // =========================================================================
-    /** Check compaction decision and trigger if needed. */
     async _triggerCompactionIfNeeded(msg, skipAbortedCheck, opts) {
-        return triggerCompactionIfNeeded(this._compactionTriggerDeps, msg, skipAbortedCheck, opts);
+        return triggerCompactionIfNeeded(this._compactionTriggerDeps, msg, skipAbortedCheck, {
+            ...opts,
+            heartbeatWrap: this._createCompactionObservabilityWrap()
+        });
+    }
+    _createCompactionObservabilityWrap() {
+        return createCompactionObservabilityWrap({
+            observability: this._observability,
+            nextOpId: () => `compaction_${++this._nextCompactionOpId}`
+        });
     }
     /** Run a manual compaction pass over the conversation, optionally with custom instructions. */
     async compact(customInstructions) {
@@ -1398,7 +1403,9 @@ export class AgentSession {
             const apiKey = await this._modelRegistry.getApiKey(this.model);
             if (!apiKey)
                 throw new Error(`No API key for ${this.model.provider}`);
-            return await this._compaction.runManual(this.model, apiKey, this.sessionManager.getBranch(), customInstructions, this._compactionActions, { userMessageId: getActiveUserMessageId(this.messages) });
+            const compact = this._compaction.runManual(this.model, apiKey, this.sessionManager.getBranch(), customInstructions, this._compactionActions, { userMessageId: getActiveUserMessageId(this.messages) });
+            const wrap = this._createCompactionObservabilityWrap();
+            return await (wrap ? wrap(compact, 'compaction', { label: 'Compacting context…' }) : compact);
         }
         finally {
             this._reconnectToAgent();

package/dist/app/providers/model-resolver.js

@@ -3,7 +3,7 @@
  */
 import chalk from 'chalk';
 import { DEFAULT_THINKING_LEVEL, isValidThinkingLevel } from '../../core/defaults.js';
-import { SHORTCUT_MODEL_ID, SHORTCUT_PROVIDER_ID } from '../../model-ids.js';
+import { SHORTCUT_MODEL_ID, SHORTCUT_OPENAI_MODEL_ID, SHORTCUT_PROVIDER_ID } from '../../model-ids.js';
 export function formatModelRef(model) {
     return `${model.provider}/${model.id}`;
 }
@@ -36,13 +36,13 @@ export function resolveExactModelRef(availableModels, requested) {
 }
 /** Default model IDs for each provider with a preferred initial model. */
 export const defaultModelPerProvider = {
-    [SHORTCUT_PROVIDER_ID]: SHORTCUT_MODEL_ID.ClaudeFable5,
+    [SHORTCUT_PROVIDER_ID]: SHORTCUT_OPENAI_MODEL_ID,
     anthropic: SHORTCUT_MODEL_ID.ClaudeOpus48,
-    openai: 'gpt-5.5-2026-04-23',
-    'azure-openai-responses': 'gpt-5.5-2026-04-23',
+    openai: SHORTCUT_OPENAI_MODEL_ID,
+    'azure-openai-responses': SHORTCUT_OPENAI_MODEL_ID,
     google: 'gemini-2.5-pro',
     'google-vertex': 'gemini-3-pro-preview',
-    openrouter: 'openai/gpt-5.5-2026-04-23',
+    openrouter: `openai/${SHORTCUT_OPENAI_MODEL_ID}`,
     'vercel-ai-gateway': 'anthropic/claude-opus-4-8',
     xai: 'grok-4-fast-non-reasoning',
     groq: 'openai/gpt-oss-120b',
@@ -56,7 +56,11 @@ export const defaultModelPerProvider = {
 };
 function getDefaultModelCandidatesForProvider(provider) {
     if (provider === SHORTCUT_PROVIDER_ID) {
-        return [SHORTCUT_MODEL_ID.ClaudeFable5, SHORTCUT_MODEL_ID.ClaudeOpus48];
+        return [
+            SHORTCUT_OPENAI_MODEL_ID,
+            SHORTCUT_MODEL_ID.ClaudeFable5,
+            SHORTCUT_MODEL_ID.ClaudeOpus48
+        ];
     }
     return [defaultModelPerProvider[provider]].filter((modelId) => !!modelId);
 }
@@ -271,7 +275,7 @@ export function resolveCliModel(options) {
     }
     // If we inferred a provider from the slash but found no match within that provider,
     // fall back to matching the full input as a raw model id across all models.
-    // This handles OpenRouter-style IDs like "openai/gpt-5.5-2026-04-23:extended" where "openai"
+    // This handles OpenRouter-style IDs like "openai/<model>:extended" where "openai"
     // looks like a provider but the full string is actually a model id on openrouter.
     if (inferredProvider) {
         const lower = cliModel.toLowerCase();

package/dist/app/providers/register-shortcut-provider.js

@@ -14,6 +14,7 @@ import { streamSimpleOpenAICompletions } from '../../ai/providers/openai-complet
 import { streamSimpleOpenAIResponses } from '../../ai/providers/openai-responses.js';
 import { NPM_PACKAGE_NAME, VERSION } from '../../config.js';
 import { gatewayBaseUrlForTransport } from '../../embedded-agent/gateway-base-url.js';
+import { OPENAI_PRIORITY_SERVICE_TIER, shortcutProviderFastModeForContext, shortcutSpeedFromOptions, withProviderFastModeHeaders, withProviderFastModePayloadOverride } from '../../embedded-agent/provider-fast-mode.js';
 import { SHORTCUT_PROVIDER_ID } from '../../model-ids.js';
 import { createShortcutModelDefinitions } from '../../shortcut-model-catalog.js';
 import { shortcutOAuth } from '../auth/shortcut-oauth.js';
@@ -72,11 +73,15 @@ function createShortcutApiV2AttributionHeaders(options) {
     if (attribution?.fileAttachmentIds?.length) {
         headers['X-File-Attachment-Ids'] = attribution.fileAttachmentIds.join(',');
     }
-    if (attribution?.speed === 'fast' || attribution?.speed === 'standard') {
-        headers['X-Shortcut-Speed'] = attribution.speed;
-    }
     return headers;
 }
+function providerFastModeKindForTransport(transport) {
+    if (transport === 'anthropic-messages')
+        return 'anthropic';
+    if (transport === 'openai-completions' || transport === 'openai-responses')
+        return 'openai';
+    return undefined;
+}
 /**
  * Dispatch a Shortcut model to its provider-native stream function, routed at
  * the api-v2 gateway with Shortcut auth. `options.apiKey` is the Shortcut
@@ -110,10 +115,21 @@ export function createShortcutApiV2Dispatcher(getExtraHeaders) {
             api: transport,
             baseUrl: gatewayBaseUrlForTransport(model.baseUrl, transport)
         };
-        return streamFn(nativeModel, context, {
+        const providerFastModeKind = providerFastModeKindForTransport(transport);
+        const fastMode = providerFastModeKind
+            ? shortcutProviderFastModeForContext({
+                context,
+                modelId: model.id,
+                provider: providerFastModeKind,
+                speed: shortcutSpeedFromOptions(options)
+            })
+            : undefined;
+        const streamOptions = withProviderFastModePayloadOverride({
             ...options,
-            headers: { ...authHeaders, ...options?.headers }
-        });
+            headers: withProviderFastModeHeaders({ ...authHeaders, ...options?.headers }, fastMode),
+            ...(fastMode === 'openai' ? { serviceTier: OPENAI_PRIORITY_SERVICE_TIER } : {})
+        }, fastMode);
+        return streamFn(nativeModel, context, streamOptions);
     };
 }
 /** Register the Shortcut provider, routing all models through the api-v2 gateway. */

package/dist/app/providers/shortcut-llm-proxy-client.js

@@ -118,8 +118,6 @@ function createShortcutLlmProxyHeaders(request, attribution) {
         headers['X-Turn-Id'] = attribution.userMessageId;
     if (request.llmOperation)
         headers['X-LLM-Operation'] = request.llmOperation;
-    if (request.speed)
-        headers['X-Shortcut-Speed'] = request.speed;
     return Object.keys(headers).length > 0 ? headers : undefined;
 }
 /**
@@ -148,7 +146,8 @@ export function createShortcutLlmProxyClient(options) {
                 apiKey,
                 maxTokens: request.max_tokens ?? request.max_output_tokens,
                 signal: callOptions?.signal,
-                headers
+                headers,
+                ...(request.speed !== undefined ? { speed: request.speed } : {})
             });
             const text = await collectAssistantText(stream);
             if (!text.trim()) {

package/dist/app/session/compaction-observability.d.ts

@@ -0,0 +1,17 @@
+import type { HeartbeatWrapFn } from '../../core/agent-engine.js';
+export interface CompactionObservability {
+    info?: (input: {
+        module: string;
+        event: string;
+        analyticsEvent?: boolean;
+        data?: Record<string, unknown>;
+        duration?: number;
+    }) => void;
+}
+export interface CreateCompactionObservabilityWrapOptions {
+    nextOpId: () => string;
+    now?: () => number;
+    observability?: CompactionObservability;
+}
+export declare function createCompactionObservabilityWrap(options: CreateCompactionObservabilityWrapOptions): HeartbeatWrapFn | undefined;
+//# sourceMappingURL=compaction-observability.d.ts.map