shortcutxl 0.3.76 → 0.3.78

package/dist/embedded-agent/provider-native-request.js

@@ -0,0 +1,65 @@
+import { gatewayModelForTransport } from './gateway-base-url.js';
+import { OPENAI_PRIORITY_SERVICE_TIER, shortcutProviderFastModeFromRequest, withProviderFastModeHeaders, withProviderFastModePayload, withProviderFastModePayloadOverride } from './provider-fast-mode.js';
+function fastModeProvider(transport) {
+    if (transport === 'anthropic-messages')
+        return 'anthropic';
+    if (transport === 'openai-completions' || transport === 'openai-responses')
+        return 'openai';
+    return undefined;
+}
+export function createGatewayProviderModel(request, transport, baseUrl) {
+    return gatewayModelForTransport(request.model, baseUrl, transport);
+}
+function authHeaders(auth, transport) {
+    if (auth.headerName === 'Authorization') {
+        return {
+            Authorization: auth.token.startsWith('Bearer ') ? auth.token : `Bearer ${auth.token}`,
+            ...(transport === 'anthropic-messages'
+                ? {
+                    // Prevent the Anthropic SDK from also sending the gateway token as x-api-key.
+                    'x-api-key': null
+                }
+                : {})
+        };
+    }
+    return { 'x-api-key': auth.token };
+}
+export function concreteProviderHeaders(headers) {
+    return Object.fromEntries(Object.entries(headers ?? {}).filter((entry) => entry[1] !== null));
+}
+export function createGatewayProviderOptions(request, transport, options, defaults = {}) {
+    const fastProvider = fastModeProvider(transport);
+    const fastMode = fastProvider
+        ? shortcutProviderFastModeFromRequest(fastProvider, request)
+        : undefined;
+    const headers = withProviderFastModeHeaders({
+        ...request.options?.headers,
+        ...options.headers,
+        ...authHeaders(options.auth, transport)
+    }, fastMode);
+    const thinkingType = request.options && 'thinkingType' in request.options ? request.options.thinkingType : undefined;
+    const reasoning = thinkingType === 'off'
+        ? 'off'
+        : (request.options?.reasoning ?? (thinkingType === 'on' ? 'high' : undefined));
+    return withProviderFastModePayloadOverride({
+        apiKey: options.auth.token,
+        cacheRetention: request.options?.cacheRetention,
+        fetch: options.fetchImpl,
+        fetchOptions: options.fetchOptions,
+        headers: headers,
+        maxRetryDelayMs: request.options?.maxRetryDelayMs,
+        maxTokens: request.options?.maxTokens ?? defaults.maxTokens,
+        metadata: request.options?.metadata,
+        reasoning,
+        signal: defaults.signal,
+        temperature: request.options?.temperature,
+        toolChoice: request.options?.toolChoice,
+        transport: request.options?.transport,
+        ...(fastMode === 'openai' ? { serviceTier: OPENAI_PRIORITY_SERVICE_TIER } : {})
+    }, fastMode);
+}
+export function applyGatewayProviderPayload(request, transport, payload) {
+    const provider = fastModeProvider(transport);
+    return withProviderFastModePayload(payload, provider ? shortcutProviderFastModeFromRequest(provider, request) : undefined);
+}
+//# sourceMappingURL=provider-native-request.js.map

package/dist/embedded-agent/run-stats.d.ts

@@ -10,7 +10,7 @@ export type { RunStatsEntry, RunStatsModelUsage, RunStatsSnapshot, RunStatsToken
 /** Per-turn config stamped on the run-stats entry, captured at run-start post-swap. */
 export interface RunStatsRunConfig {
     readonly modelName?: string;
-    readonly effortLevel?: 'low' | 'medium' | 'high' | 'max';
+    readonly effortLevel?: 'low' | 'medium' | 'high' | 'xhigh' | 'max';
     readonly speed?: 'fast' | 'standard';
 }
 export interface RunStatsAccumulator {

package/dist/embedded-agent/stream.d.ts

@@ -1,8 +1,10 @@
-import { type Api, type Context, type Model, type SimpleStreamOptions } from '../ai/types.js';
+/** Provider-neutral request tracing helpers shared by embedded transports. */
+import type { Api, Context, Model, ReasoningLevel, SimpleStreamOptions } from '../ai/types.js';
 import { type ShortcutXLModelStreamEvent, type ShortcutXLModelStreamFetchTrace, type ShortcutXLModelStreamMessage, type ShortcutXLModelStreamRequest } from '../contracts/model-stream.js';
 type ShortcutRuntimeMessage = ShortcutXLModelStreamMessage;
+export declare function toShortcutEffortLevel(effort: ReasoningLevel | undefined): ShortcutXLModelStreamRequest['effortLevel'];
 export interface ShortcutRuntimeRequestBody {
-    effort_level?: 'low' | 'medium' | 'high' | 'max';
+    effort_level?: 'low' | 'medium' | 'high' | 'xhigh' | 'max';
     max_tokens?: number;
     messages: {
         content: string;
@@ -17,12 +19,6 @@ export interface ShortcutRuntimeRequestBody {
         }[];
     }[];
     model: string;
-    user_message_id?: string;
-    /**
-     * Selected speed mode. The proxy's `LLMRequest.speed` field validates
-     * `'fast' | 'standard'`. Server-side gating ensures fast mode only
-     * applies to supported models.
-     */
     speed?: 'fast' | 'standard';
     thinking_type?: 'adaptive' | 'off';
     tools?: {
@@ -30,104 +26,22 @@ export interface ShortcutRuntimeRequestBody {
         name: string;
         parameters: Record<string, unknown>;
     }[];
+    user_message_id?: string;
 }
-interface ShortcutXLModelStreamWorkspaceContext {
-    readonly workspaceId?: string;
-    readonly workspaceType?: 'file' | 'project' | 'global';
-}
-/**
- * Owned AI `thinkingLevel` ↔ proxy's `effort_level`. Exported so the
- * run-stats accumulator can stamp the same effort label on the run-stats
- * entry that the proxy actually used. Keeping a single source of truth
- * prevents drift between what the LLM saw and what the dropdown shows.
- */
-export declare const ShortcutThinkingLevelToEffort: {
-    readonly minimal: "low";
-    readonly low: "low";
-    readonly medium: "medium";
-    readonly high: "high";
-    readonly xhigh: "max";
-};
-/** Host plumbing the embedded runtime needs to reach the stream endpoint. */
-export interface ShortcutXLModelStreamHostOptions {
-    readonly baseUrl?: string;
-    readonly clientPlatform: string;
-    readonly fetchImpl?: typeof fetch;
-    /** Override only the legacy `/api/llm/stream` fetch URL. Defaults to `baseUrl`. */
-    readonly streamBaseUrl?: string;
-    readonly getAccessToken?: () => Promise<string | undefined>;
-    /**
-     * Refreshes host-owned credentials after a 401 from the stream proxy. Workers
-     * cannot refresh auth directly, so they call back into the host through this
-     * hook and retry the stream request once.
-     */
-    readonly refreshAccessToken?: () => Promise<string | undefined>;
-    /**
-     * Resolves the active conversation thread id at request time. Sent as the
-     * `X-Session-Id` header — the backend `/api/llm/stream` proxy uses it for
-     * `langfuse_session_id`, `thread_id` on token-event webhooks, and
-     * trace grouping. Without this, every call is bucketed under the
-     * synthetic fallback `llm-proxy-{user_id}` and per-thread reconciliation
-     * breaks.
-     */
-    readonly getSessionId?: () => string | undefined;
-    readonly getWorkspaceContext?: () => ShortcutXLModelStreamWorkspaceContext | undefined;
-    /**
-     * Observability hook fired after the runtime has normalized context/options
-     * into the exact JSON payload shape sent to `/api/llm/stream`.
-     * Credentials and transport headers are intentionally excluded.
-     */
-    readonly onRequest?: (request: ShortcutXLModelStreamRequest, body: ShortcutRuntimeRequestBody) => void;
-    /**
-     * Diagnostic hook fired when a stream fetch fails. Distinguishes failure
-     * stages that aren't visible in the generic `recovery_started` telemetry:
-     *   - `before_response`: `fetch()` rejected before any `Response` (DNS,
-     *     CORS preflight, network unreachable, captive portal). The
-     *     opaque "Failed to fetch" / "Load failed" case.
-     *   - `non_ok_response`: backend returned a response with status outside 2xx.
-     *   - `response_body`: the response started but the SSE read failed or
-     *     idle-timed out mid-stream.
-     * Headers/body intentionally excluded — only diagnostic metadata is sent.
-     */
+/** Provider-native transports use these shared stream callbacks. */
+export interface RunShortcutXLModelStreamRequestOptions {
+    onEvent(event: ShortcutXLModelStreamEvent): void;
     readonly onFetchTrace?: (event: ShortcutXLModelStreamFetchTrace) => void;
-    /** Retry budget for retryable stream transport failures. Defaults to 2 retries. */
-    readonly maxStreamRetries?: number;
-    readonly streamRetryBaseDelayMs?: number;
-    readonly streamRetryMaxDelayMs?: number;
-    /**
-     * Ceiling for server-supplied `Retry-After` delays. Distinct from
-     * `streamRetryMaxDelayMs` (which only bounds client-computed backoff).
-     */
-    readonly streamRetryServerMaxDelayMs?: number;
+    readonly signal?: AbortSignal;
 }
-/** Inputs needed to assemble the wire-shape stream request. */
 export interface CreateShortcutXLModelStreamRequestOptions {
     readonly context: Context;
     readonly model: Model<Api>;
     readonly options?: SimpleStreamOptions;
     readonly requestId: string;
 }
-/** Per-call options layered on top of host options for `runShortcutXL...`. */
-export interface RunShortcutXLModelStreamRequestOptions extends ShortcutXLModelStreamHostOptions {
-    readonly apiKey?: string;
-    onEvent(event: ShortcutXLModelStreamEvent): void;
-    readonly signal?: AbortSignal;
-    readonly streamIdleTimeoutMs?: number;
-}
-/** Convert owned AI `Context` + model into the ShortcutXL stream request shape. */
+/** Convert owned AI context into the stable request-trace shape. */
 export declare function createShortcutXLModelStreamRequest(options: CreateShortcutXLModelStreamRequestOptions): ShortcutXLModelStreamRequest;
 export declare function buildShortcutRuntimeRequestBody(request: ShortcutXLModelStreamRequest): ShortcutRuntimeRequestBody;
-/**
- * Drive one stream request to completion. Emits Start/Delta/.../Done|Error
- * events through `onEvent`. Always emits a terminal Error event on abort or
- * failure so consumers never need to time out.
- */
-export declare function runShortcutXLModelStreamRequest(request: ShortcutXLModelStreamRequest, options: RunShortcutXLModelStreamRequestOptions): Promise<void>;
-/**
- * Build a owned AI-compatible `streamFn` bound to the given host. The returned
- * function fires off one request per call and pushes events into a fresh
- * assistant-message event stream.
- */
-export declare function createShortcutXLModelStream(hostOptions: ShortcutXLModelStreamHostOptions): (model: Model<Api>, context: Context, options?: SimpleStreamOptions) => import("../ai/event-stream.js").AssistantMessageEventStream;
 export {};
 //# sourceMappingURL=stream.d.ts.map