@code-yeongyu/senpi-ai 2026.10.10 → 2026.10.11

package/dist/api/openai-completions.js

@@ -14,7 +14,7 @@ import { getProviderEnvValue } from "../utils/provider-env.js";
 import { retryProviderStreamRequest } from "../utils/provider-retry.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
 import { getSystemMessageText, renderSystemMessageUpdate } from "../utils/text.js";
-import { sendWithForcedToolChoiceFallback } from "../utils/tool-choice-fallback.js";
+import { primeStreamUntilContent, sendWithForcedToolChoiceFallback } from "../utils/tool-choice-fallback.js";
 import { normalizeToolParametersForMoonshot, normalizeToolParametersForOpenAICompat, } from "../utils/tool-schema-compat.js";
 import { getCurrentTools, getDeclaredTools, resolveTranscript, resolveTranscriptTools, } from "../utils/transcript.js";
 import { appendGrammarToolInputJsonDelta, createGrammarToolInputProperties, getGrammarToolInput, getJsonSchemaToolParameters, resolveGrammarConstrainedSampling, resolveJsonSchemaStrictSampling, } from "./constrained-sampling.js";
@@ -169,6 +169,23 @@ function getOpenRouterRawMetadata(error) {
 function isForcedOpenAICompletionsToolChoice(toolChoice) {
     return toolChoice !== undefined && toolChoice !== "auto" && toolChoice !== "none";
 }
+/** A chunk that carries model output or a finish: text, reasoning, a tool call, or a finish_reason. */
+function chatChunkHasContent(chunk) {
+    if (!isRecord(chunk) || !Array.isArray(chunk.choices))
+        return false;
+    return chunk.choices.some((choice) => {
+        if (!isRecord(choice))
+            return false;
+        if (typeof choice.finish_reason === "string" && choice.finish_reason.length > 0)
+            return true;
+        const delta = choice.delta;
+        if (!isRecord(delta))
+            return false;
+        if (Array.isArray(delta.tool_calls) && delta.tool_calls.length > 0)
+            return true;
+        return ["content", "reasoning_content", "reasoning", "reasoning_text"].some((field) => typeof delta[field] === "string" && delta[field].length > 0);
+    });
+}
 function isReasoningDetailObject(detail) {
     return typeof detail === "object" && detail !== null && !Array.isArray(detail);
 }
@@ -362,7 +379,14 @@ export const stream = (model, context, options) => {
                     params,
                     acceptsForcedToolChoice: compat.supportsForcedToolChoice !== false,
                     isForced: isForcedOpenAICompletionsToolChoice,
-                    send: createStream,
+                    // A keepalive gateway answers 200 and refuses a forced choice in-band (senpi#2801): a forced
+                    // request is read up to its first content so that refusal can still be retried.
+                    send: async (sentParams) => {
+                        const created = await createStream(sentParams);
+                        if (!isForcedOpenAICompletionsToolChoice(sentParams.tool_choice))
+                            return created;
+                        return { ...created, data: await primeStreamUntilContent(created.data, chatChunkHasContent) };
+                    },
                 });
                 params = sent.params;
                 return sent.result;

package/dist/api/openai-responses-allowed-tools.d.ts

@@ -0,0 +1,33 @@
+import type { ResponseCreateParamsStreaming } from "openai/resources/responses/responses.js";
+import type { Api, Model, OpenAIResponsesCompat, TranscriptContext } from "../types.ts";
+export type AllowedToolsTarget = Pick<Model<Api>, "api" | "provider" | "baseUrl" | "id">;
+export declare function hasRefusedAllowedToolsChoice(target: AllowedToolsTarget): boolean;
+export declare function rememberAllowedToolsChoiceRefusal(target: AllowedToolsTarget): void;
+export declare function clearAllowedToolsChoiceRefusals(): void;
+/**
+ * A refusal of `allowed_tools` as a `tool_choice` type, sent to a request that carried one. Over HTTP it is
+ * a 400; a WebSocket error event before any content carries no status, so the caller vouches for it with
+ * `beforeContent`. Observed on a Responses-compatible gateway: "Invalid value: 'allowed_tools'. Supported
+ * values are: ..." with param `tool_choice.type`.
+ */
+export declare function isAllowedToolsChoiceRefusal(error: unknown, params: {
+    readonly tool_choice?: unknown;
+}, options?: {
+    readonly beforeContent?: boolean;
+}): boolean;
+/**
+ * The pre-senpi#2095 request shape for an `allowed_tools` request: top-level function and custom tools
+ * outside the allowed list leave `tools`, hosted tools stay, and `tool_choice` goes. Tools that transcript
+ * items load in place are not filtered; a call to an inactive one is still refused by the session's active
+ * tool set. Any other request is unchanged.
+ */
+export declare function restrictToAllowedTools<TParams extends ResponseCreateParamsStreaming>(params: TParams): TParams;
+/**
+ * senpi#2095: `tools` carries every tool declared this session, so removing a tool never rewrites the
+ * cached prefix; the callable subset rides `tool_choice: allowed_tools` instead. Hosted tools a payload
+ * hook added stay callable, and deferred tools (declared by transcript items rather than `tools`) are
+ * referenced by name. A declared tool a payload hook removed from `tools` is not referenced (senpi#2234).
+ * An empty subset forbids tool calls. An explicit `tool_choice` always wins.
+ */
+export declare function applyAllowedToolsChoice<TParams extends ResponseCreateParamsStreaming>(params: TParams, context: TranscriptContext, activeToolNames: readonly string[] | undefined, compat: Required<OpenAIResponsesCompat>): TParams;
+//# sourceMappingURL=openai-responses-allowed-tools.d.ts.map

package/dist/api/openai-responses-allowed-tools.js

@@ -0,0 +1,108 @@
+import { isRequestRefusal } from "../utils/tool-choice-fallback.js";
+import { getCurrentTools } from "../utils/transcript.js";
+import { convertResponsesTools, resolveResponsesDeferredToolsMode, resolveResponsesToolPlacement, } from "./openai-responses-shared.js";
+/**
+ * Models whose endpoint refused `tool_choice: allowed_tools` and then accepted the same request
+ * restricted to the active tools, for the life of the process (senpi#3080).
+ */
+const allowedToolsRefusals = new Set();
+function refusalKey(target) {
+    return JSON.stringify([target.api, target.provider, target.baseUrl, target.id]);
+}
+export function hasRefusedAllowedToolsChoice(target) {
+    return allowedToolsRefusals.has(refusalKey(target));
+}
+export function rememberAllowedToolsChoiceRefusal(target) {
+    allowedToolsRefusals.add(refusalKey(target));
+}
+export function clearAllowedToolsChoiceRefusals() {
+    allowedToolsRefusals.clear();
+}
+function allowedReference(tool) {
+    if (tool.type === "function" || tool.type === "custom")
+        return { type: tool.type, name: tool.name };
+    if (tool.type === "mcp")
+        return { type: "mcp", server_label: tool.server_label };
+    return { type: tool.type };
+}
+function allowedToolsChoice(params) {
+    const choice = params.tool_choice;
+    if (typeof choice !== "object" || choice === null)
+        return undefined;
+    const { type, tools } = choice;
+    return type === "allowed_tools" && Array.isArray(tools) ? tools : undefined;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/**
+ * A refusal of `allowed_tools` as a `tool_choice` type, sent to a request that carried one. Over HTTP it is
+ * a 400; a WebSocket error event before any content carries no status, so the caller vouches for it with
+ * `beforeContent`. Observed on a Responses-compatible gateway: "Invalid value: 'allowed_tools'. Supported
+ * values are: ..." with param `tool_choice.type`.
+ */
+export function isAllowedToolsChoiceRefusal(error, params, options = {}) {
+    if (allowedToolsChoice(params) === undefined)
+        return false;
+    if (!options.beforeContent && !isRequestRefusal(error))
+        return false;
+    const message = errorMessage(error);
+    return /\ballowed_tools\b/.test(message) && /invalid|unsupported|not\s+supported/i.test(message);
+}
+/**
+ * The pre-senpi#2095 request shape for an `allowed_tools` request: top-level function and custom tools
+ * outside the allowed list leave `tools`, hosted tools stay, and `tool_choice` goes. Tools that transcript
+ * items load in place are not filtered; a call to an inactive one is still refused by the session's active
+ * tool set. Any other request is unchanged.
+ */
+export function restrictToAllowedTools(params) {
+    const allowed = allowedToolsChoice(params);
+    if (allowed === undefined)
+        return params;
+    const allowedNames = new Set(allowed.map((tool) => tool.name).filter((name) => typeof name === "string"));
+    const tools = (params.tools ?? []).filter((tool) => (tool.type !== "function" && tool.type !== "custom") || allowedNames.has(tool.name));
+    const restricted = { ...params, tools };
+    delete restricted.tool_choice;
+    return restricted;
+}
+/**
+ * senpi#2095: `tools` carries every tool declared this session, so removing a tool never rewrites the
+ * cached prefix; the callable subset rides `tool_choice: allowed_tools` instead. Hosted tools a payload
+ * hook added stay callable, and deferred tools (declared by transcript items rather than `tools`) are
+ * referenced by name. A declared tool a payload hook removed from `tools` is not referenced (senpi#2234).
+ * An empty subset forbids tool calls. An explicit `tool_choice` always wins.
+ */
+export function applyAllowedToolsChoice(params, context, activeToolNames, compat) {
+    if (!compat.supportsAllowedTools || activeToolNames === undefined || params.tool_choice !== undefined) {
+        return params;
+    }
+    const active = new Set(activeToolNames);
+    const declaredTools = getCurrentTools(context.messages);
+    if (declaredTools.every((tool) => active.has(tool.name)))
+        return params;
+    const allowed = [];
+    const namedInTools = new Set();
+    for (const tool of params.tools ?? []) {
+        if (tool.type === "function" || tool.type === "custom") {
+            namedInTools.add(tool.name);
+            if (!active.has(tool.name))
+                continue;
+        }
+        allowed.push(allowedReference(tool));
+    }
+    // Tools missing from the request-level `tools` placement are the ones transcript items load in place.
+    const requestToolNames = new Set(resolveResponsesToolPlacement(context.messages, resolveResponsesDeferredToolsMode(compat) !== undefined).requestTools.map((tool) => tool.name));
+    for (const tool of declaredTools) {
+        if (namedInTools.has(tool.name) || !active.has(tool.name) || requestToolNames.has(tool.name))
+            continue;
+        const [converted] = convertResponsesTools([tool], {
+            supportsStrictMode: compat.supportsStrictMode,
+            supportsOpenAIGrammarTools: compat.supportsOpenAIGrammarTools,
+        });
+        if (converted)
+            allowed.push(allowedReference(converted));
+    }
+    const toolChoice = allowed.length > 0 ? { type: "allowed_tools", mode: "auto", tools: allowed } : "none";
+    return { ...params, tool_choice: toolChoice };
+}
+//# sourceMappingURL=openai-responses-allowed-tools.js.map

package/dist/api/openai-responses.js

@@ -1,5 +1,6 @@
 import OpenAI from "openai";
 import { calculateCost, clampThinkingLevel, inferOpenAIThinkingLevelMap, supportsMax, supportsXhigh, } from "../models.js";
+import { supportsAllowedToolChoice } from "../openai-responses-compat.js";
 import { readProviderDiagnostic } from "../provider-diagnostic.js";
 import { formatProviderError, normalizeProviderError } from "../utils/error-body.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
@@ -10,13 +11,14 @@ import { awaitProviderTransport, openAICompatibleProviderDiagnosticFromError, }
 import { getProviderEnvValue } from "../utils/provider-env.js";
 import { retryProviderRequest } from "../utils/provider-retry.js";
 import { sendWithForcedToolChoiceFallback } from "../utils/tool-choice-fallback.js";
-import { getCurrentTools, getDeclaredTools, normalizeContext, resolveTranscript } from "../utils/transcript.js";
+import { getDeclaredTools, normalizeContext, resolveTranscript } from "../utils/transcript.js";
 import { isCloudflareProvider, resolveCloudflareBaseUrl } from "./cloudflare.js";
 import { createGrammarToolInputProperties } from "./constrained-sampling.js";
 import { withGitHubCopilotFailureNote } from "./github-copilot-errors.js";
 import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
 import { resolveOpenAIClientAuth } from "./openai-client-auth.js";
 import { clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
+import { applyAllowedToolsChoice, hasRefusedAllowedToolsChoice, isAllowedToolsChoiceRefusal, rememberAllowedToolsChoiceRefusal, restrictToAllowedTools, } from "./openai-responses-allowed-tools.js";
 import { findPromptCacheComparisonResponseId, withPromptCacheComparison, } from "./openai-responses-prompt-cache.js";
 import { convertResponsesMessages, convertResponsesTools, processResponsesStream, resolveResponsesDeferredToolsMode, resolveResponsesToolPlacement, } from "./openai-responses-shared.js";
 import { buildBaseOptions, clampMaxForOpenAI, OPENAI_RESPONSES_RESERVED_BODY_KEYS } from "./simple-options.js";
@@ -70,7 +72,7 @@ function getCompat(model, env) {
         supportsConfigurationUpdate: model.compat?.supportsConfigurationUpdate ?? false,
         supportsMaxOutputTokens: model.compat?.supportsMaxOutputTokens ?? true,
         supportsForcedToolChoice: model.compat?.supportsForcedToolChoice ?? true,
-        supportsAllowedTools: model.compat?.supportsAllowedTools ?? false,
+        supportsAllowedTools: supportsAllowedToolChoice(model),
     };
 }
 function isOpenAIResponsesNativeEndpoint(model, env) {
@@ -141,53 +143,6 @@ function sanitizeUnsupportedNativeTools(params, compat) {
     }
     return sanitized ? sanitized : params;
 }
-function allowedReference(tool) {
-    if (tool.type === "function" || tool.type === "custom")
-        return { type: tool.type, name: tool.name };
-    if (tool.type === "mcp")
-        return { type: "mcp", server_label: tool.server_label };
-    return { type: tool.type };
-}
-/**
- * senpi#2095: `tools` carries every tool declared this session, so removing a tool never rewrites the
- * cached prefix; the callable subset rides `tool_choice: allowed_tools` instead. Hosted tools a payload
- * hook added stay callable, and deferred tools (declared by transcript items rather than `tools`) are
- * referenced by name. A declared tool a payload hook removed from `tools` is not referenced (senpi#2234).
- * An empty subset forbids tool calls. An explicit `tool_choice` always wins.
- */
-function applyAllowedToolsChoice(params, context, activeToolNames, compat) {
-    if (!compat.supportsAllowedTools || activeToolNames === undefined || params.tool_choice !== undefined) {
-        return params;
-    }
-    const active = new Set(activeToolNames);
-    const declaredTools = getCurrentTools(context.messages);
-    if (declaredTools.every((tool) => active.has(tool.name)))
-        return params;
-    const allowed = [];
-    const namedInTools = new Set();
-    for (const tool of params.tools ?? []) {
-        if (tool.type === "function" || tool.type === "custom") {
-            namedInTools.add(tool.name);
-            if (!active.has(tool.name))
-                continue;
-        }
-        allowed.push(allowedReference(tool));
-    }
-    // Tools missing from the request-level `tools` placement are the ones transcript items load in place.
-    const requestToolNames = new Set(resolveResponsesToolPlacement(context.messages, resolveResponsesDeferredToolsMode(compat) !== undefined).requestTools.map((tool) => tool.name));
-    for (const tool of declaredTools) {
-        if (namedInTools.has(tool.name) || !active.has(tool.name) || requestToolNames.has(tool.name))
-            continue;
-        const [converted] = convertResponsesTools([tool], {
-            supportsStrictMode: compat.supportsStrictMode,
-            supportsOpenAIGrammarTools: compat.supportsOpenAIGrammarTools,
-        });
-        if (converted)
-            allowed.push(allowedReference(converted));
-    }
-    const toolChoice = allowed.length > 0 ? { type: "allowed_tools", mode: "auto", tools: allowed } : "none";
-    return { ...params, tool_choice: toolChoice };
-}
 function formatOpenAIResponsesError(error, provider) {
     const errorMessage = formatProviderError(normalizeProviderError(error), `${provider === "openai" ? "OpenAI" : provider} API error`);
     // Sign in with ChatGPT shares the subscription's usage limit with other apps.
@@ -234,12 +189,15 @@ export const stream = (model, context, options) => {
             }
             params = sanitizeUnsupportedNativeTools(params, compat);
             params = applyAllowedToolsChoice(params, normalizedContext, context.activeToolNames, compat);
+            if (hasRefusedAllowedToolsChoice(model))
+                params = restrictToAllowedTools(params);
             const limitedTools = limitGitHubCopilotTools(model.provider, params.tools, params.tool_choice);
             if (limitedTools.omittedCount > 0) {
                 params = { ...params, tools: limitedTools.tools };
                 recordGitHubCopilotToolLimit(output, limitedTools.omittedCount);
             }
             const transport = options?.transport ?? "sse";
+            let refusedAllowedToolsOverWebSocket = false;
             if (transport !== "sse" && compat.supportsWebSocket) {
                 let websocketStarted = false;
                 try {
@@ -254,9 +212,16 @@ export const stream = (model, context, options) => {
                     return;
                 }
                 catch (error) {
-                    if (transport === "websocket" || websocketStarted) {
+                    const refusedAllowedTools = output.content.length === 0 && isAllowedToolsChoiceRefusal(error, params, { beforeContent: true });
+                    if (!refusedAllowedTools && (transport === "websocket" || websocketStarted)) {
                         throw error;
                     }
+                    if (refusedAllowedTools) {
+                        params = restrictToAllowedTools(params);
+                        refusedAllowedToolsOverWebSocket = true;
+                        output.stopReason = "pending";
+                        delete output.errorMessage;
+                    }
                 }
             }
             const requestOptions = {
@@ -264,26 +229,46 @@ export const stream = (model, context, options) => {
                 ...(options?.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
                 maxRetries: 0,
             };
-            const createRequest = async () => {
+            const sendOnce = async (body) => {
                 const sent = await sendWithForcedToolChoiceFallback({
                     target: model,
-                    params,
+                    params: body,
                     acceptsForcedToolChoice: compat.supportsForcedToolChoice,
                     isForced: isForcedOpenAIResponsesToolChoice,
-                    send: (body) => model.provider === "github-copilot"
-                        ? awaitProviderTransport(() => client.responses.create(body, requestOptions).withResponse(), openAICompatibleProviderDiagnosticFromError)
-                        : client.responses.create(body, requestOptions).withResponse(),
+                    send: (request) => model.provider === "github-copilot"
+                        ? awaitProviderTransport(() => client.responses.create(request, requestOptions).withResponse(), openAICompatibleProviderDiagnosticFromError)
+                        : client.responses.create(request, requestOptions).withResponse(),
                 });
                 params = sent.params;
                 return sent.result;
             };
+            // senpi#3080: an endpoint that refuses `allowed_tools` gets the request restricted to the active
+            // tools; the model is remembered once that restricted request is accepted.
+            const createRequest = async () => {
+                try {
+                    const result = await sendOnce(params);
+                    if (refusedAllowedToolsOverWebSocket)
+                        rememberAllowedToolsChoiceRefusal(model);
+                    return result;
+                }
+                catch (error) {
+                    if (!isAllowedToolsChoiceRefusal(error, params))
+                        throw error;
+                    params = restrictToAllowedTools(params);
+                    const result = await sendOnce(params);
+                    rememberAllowedToolsChoiceRefusal(model);
+                    return result;
+                }
+            };
             const { data: openaiStream, response } = await retryProviderRequest(() => createRequest(), {
                 maxRetries: options?.maxRetries,
                 maxRetryDelayMs: options?.maxRetryDelayMs,
                 signal: options?.signal,
             });
             await options?.onResponse?.({ status: response.status, headers: headersToRecord(response.headers) }, model);
-            stream.push({ type: "start", partial: output });
+            // A WebSocket attempt that fell through after its refusal already pushed `start`.
+            if (!refusedAllowedToolsOverWebSocket)
+                stream.push({ type: "start", partial: output });
             await processResponsesStream(openaiStream, output, stream, model, {
                 onProviderStreamEvent: options?.onProviderStreamEvent,
                 serviceTier: options?.serviceTier,
@@ -861,9 +846,9 @@ function buildWebSocketHeaders(model, context, apiKey, optionsHeaders, sessionId
 function getServiceTierCostMultiplier(model, serviceTier) {
     switch (serviceTier) {
         case "ultrafast":
-            // OpenAI publishes an Ultrafast price for GPT-6 Astra only: 6x Standard on every
+            // OpenAI prices GPT-6 Astra and GPT-6.1 Sol Ultrafast at 6x Standard on every
             // token class and context tier. Any other model keeps its base rate.
-            return model.id === "gpt-6-astra" ? 6 : 1;
+            return ["gpt-6-astra", "gpt-6.1-sol"].includes(model.upstreamModelId ?? model.id) ? 6 : 1;
         case "flex":
             return 0.5;
         case "priority":

package/dist/auth/oauth/anthropic.js

@@ -4,6 +4,7 @@
  * NOTE: This module uses Node.js http.createServer for the OAuth callback server.
  * It is only intended for CLI use, not browser environments.
  */
+import { OAuthTokenEndpointError } from "../../utils/oauth-refresh-error.js";
 import { getProviderEnvValue } from "../../utils/provider-env.js";
 import { PREFERRED_CALLBACK_PORT, startCallbackListener, } from "./anthropic-callback-listener.js";
 import { parseAuthorizationInput } from "./authorization-input.js";
@@ -57,7 +58,7 @@ async function postJson(url, body, signal) {
     });
     const responseBody = await response.text();
     if (!response.ok) {
-        throw new Error(`HTTP request failed. status=${response.status}; url=${url}; body=${responseBody}`);
+        throw new OAuthTokenEndpointError(`HTTP request failed. status=${response.status}; url=${url}; body=${responseBody}`, response.status);
     }
     return responseBody;
 }
@@ -74,7 +75,7 @@ async function exchangeAuthorizationCode(code, state, verifier, redirectUri, sig
         }, signal);
     }
     catch (error) {
-        throw new Error(`Token exchange request failed. url=${TOKEN_URL}; redirect_uri=${redirectUri}; response_type=authorization_code; details=${formatErrorDetails(error)}`);
+        throw new Error(`Token exchange request failed. url=${TOKEN_URL}; redirect_uri=${redirectUri}; response_type=authorization_code; details=${formatErrorDetails(error)}`, { cause: error });
     }
     let tokenData;
     try {
@@ -240,7 +241,7 @@ async function refreshAnthropicToken(refreshToken, signal) {
         }, signal);
     }
     catch (error) {
-        throw new Error(`Anthropic token refresh request failed. url=${TOKEN_URL}; details=${formatErrorDetails(error)}`);
+        throw new Error(`Anthropic token refresh request failed. url=${TOKEN_URL}; details=${formatErrorDetails(error)}`, { cause: error });
     }
     let data;
     try {

package/dist/auth/oauth/chatgpt-subscription.js

@@ -12,6 +12,7 @@ if (typeof process !== "undefined" && (process.versions?.node || process.version
     });
 }
 import { extractChatGptSubscriptionAccountId } from "../../utils/chatgpt-subscription-auth.js";
+import { OAuthTokenEndpointError } from "../../utils/oauth-refresh-error.js";
 import { getProviderEnvValue } from "../../utils/provider-env.js";
 import { getWireIdentity } from "../../wire-identity.js";
 import { startOAuthCallbackServer, waitForCallbackOrManualInput } from "./callback-server.js";
@@ -80,7 +81,7 @@ async function fetchWithLoginCancellation(input, init) {
 async function readTokenResponse(response, operation) {
     if (!response.ok) {
         const text = await response.text().catch(() => "");
-        throw new Error(`ChatGPT Subscription token ${operation} failed (${response.status}): ${text || response.statusText}`);
+        throw new OAuthTokenEndpointError(`ChatGPT Subscription token ${operation} failed (${response.status}): ${text || response.statusText}`, response.status);
     }
     const rawJson = await response.json();
     const json = rawJson;
@@ -123,7 +124,7 @@ async function refreshAccessToken(refreshToken, signal) {
         });
     }
     catch (error) {
-        throw new Error(`ChatGPT Subscription token refresh error: ${error instanceof Error ? error.message : String(error)}`);
+        throw new Error(`ChatGPT Subscription token refresh error: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
     }
     return readTokenResponse(response, "refresh");
 }

package/dist/auth/oauth/cursor.js

@@ -10,6 +10,7 @@
  * (or a dashboard user API key) at `auth/exchange_user_api_key` for a fresh
  * session JWT.
  */
+import { OAuthTokenEndpointError } from "../../utils/oauth-refresh-error.js";
 import { generatePKCE } from "./pkce.js";
 const CURSOR_LOGIN_URL = "https://cursor.com/loginDeepControl";
 const CURSOR_POLL_URL = "https://api2.cursor.sh/auth/poll";
@@ -205,12 +206,12 @@ async function refreshCursorCredential(credential, signal) {
     }
     catch (error) {
         if (signal.aborted)
-            throw new Error("Cursor token refresh cancelled");
+            throw new Error("Cursor token refresh cancelled", { cause: signal.reason });
         throw error;
     }
     const body = await readJsonBody(response);
     if (!response.ok) {
-        throw new Error(`Cursor token refresh failed (${describeFailure(response.status, body)})`);
+        throw new OAuthTokenEndpointError(`Cursor token refresh failed (${describeFailure(response.status, body)})`, response.status);
     }
     const access = requiredString(body ?? {}, "accessToken");
     const rotated = body?.refreshToken;

package/dist/auth/oauth/devin-token.js

@@ -7,6 +7,7 @@
  * "token" that serves as both the access and the refresh credential. Expiry is
  * read from the JWT itself because the response carries no expires_in.
  */
+import { OAuthTokenEndpointError } from "../../utils/oauth-refresh-error.js";
 export const DEVIN_TOKEN_URL = "https://api.devin.ai/auth/cli/token";
 export const DEVIN_API_ENDPOINT = "https://api.devin.ai";
 /** Devin issues long-lived CLI tokens; used when the JWT carries no usable exp. */
@@ -91,7 +92,7 @@ export async function exchangeDevinAuthorizationCode(code, verifier, signal) {
     }
     if (!response.ok) {
         const detail = errorDetail(body);
-        throw new Error(`Devin OAuth token exchange failed (HTTP ${response.status})${detail ? `: ${detail}` : ""}`);
+        throw new OAuthTokenEndpointError(`Devin OAuth token exchange failed (HTTP ${response.status})${detail ? `: ${detail}` : ""}`, response.status);
     }
     if (typeof body.token !== "string" || body.token.length === 0) {
         throw new Error('Devin OAuth response carries no "token"');

package/dist/auth/oauth/github-copilot.js

@@ -3,6 +3,7 @@
  */
 import { GITHUB_COPILOT_INDIVIDUAL_BASE_URL, githubCopilotTokenField, parseGitHubCopilotApiEndpoint, resolveGitHubCopilotBaseUrl, } from "../../api/github-copilot-endpoint.js";
 import { GITHUB_COPILOT_REJECTED_TOKEN_STATUSES } from "../../api/github-copilot-headers.js";
+import { OAuthTokenEndpointError } from "../../utils/oauth-refresh-error.js";
 import { sleep } from "../../utils/sleep.js";
 import { pollOAuthDeviceCodeFlow } from "./device-code.js";
 import { parseGitHubCopilotModelCatalog } from "./github-copilot-model-catalog.js";
@@ -79,7 +80,7 @@ async function fetchGitHubCopilotModels(copilotToken, enterpriseDomain, signal,
         },
     }, signal, retryPolicy);
     if (!response.ok) {
-        throw new Error(`${response.status} ${response.statusText}: ${await response.text()}`);
+        throw new OAuthTokenEndpointError(`${response.status} ${response.statusText}: ${await response.text()}`, response.status);
     }
     return parseGitHubCopilotModelCatalog(await response.json(), allowPolicyFallback);
 }
@@ -87,7 +88,7 @@ async function fetchJson(url, init) {
     const response = await fetch(url, init);
     if (!response.ok) {
         const text = await response.text();
-        throw new Error(`${response.status} ${response.statusText}: ${text}`);
+        throw new OAuthTokenEndpointError(`${response.status} ${response.statusText}: ${text}`, response.status);
     }
     return response.json();
 }

package/dist/auth/oauth/kimi-coding.js

@@ -6,6 +6,7 @@
  * access token authenticates requests to that region's coding API as an
  * `Authorization: Bearer` header; see kimi-region.ts for the host table.
  */
+import { OAuthTokenEndpointError } from "../../utils/oauth-refresh-error.js";
 import { sleep } from "../../utils/sleep.js";
 import { pollOAuthDeviceCodeFlow } from "./device-code.js";
 import { kimiCodeIdentityHeaders } from "./kimi-identity.js";
@@ -178,7 +179,7 @@ async function refreshToken(oauthHost, refreshTokenValue, signal) {
             await sleep(1000 * 2 ** (attempt - 1), signal);
         }
         if (signal.aborted) {
-            throw new Error("Kimi Code token refresh aborted");
+            throw new Error("Kimi Code token refresh aborted", { cause: signal.reason });
         }
         let response;
         try {
@@ -208,14 +209,14 @@ async function refreshToken(oauthHost, refreshTokenValue, signal) {
         // Unauthorized: the stored credential is dead; Models clears it and prompts re-login.
         if (response.status === 401 || response.status === 403 || json?.error === "invalid_grant") {
             const description = typeof json?.error_description === "string" ? `: ${json.error_description}` : "";
-            throw new Error(`Kimi Code token refresh unauthorized (status ${response.status})${description}`);
+            throw new OAuthTokenEndpointError(`Kimi Code token refresh unauthorized (status ${response.status})${description}`, response.status);
         }
         if (isRetryableRefreshFailure(response) && attempt < REFRESH_MAX_RETRIES) {
-            lastError = new Error(`Kimi Code token refresh failed with status ${response.status}`);
+            lastError = new OAuthTokenEndpointError(`Kimi Code token refresh failed with status ${response.status}`, response.status);
             continue;
         }
         const text = JSON.stringify(json);
-        throw new Error(`Kimi Code token refresh failed with status ${response.status}${text ? `: ${text}` : ""}`);
+        throw new OAuthTokenEndpointError(`Kimi Code token refresh failed with status ${response.status}${text ? `: ${text}` : ""}`, response.status);
     }
     throw lastError ?? new Error("Kimi Code token refresh failed");
 }

package/dist/auth/oauth/openai-chatgpt.js

@@ -7,6 +7,7 @@
 import { randomBytes } from "node:crypto";
 import { createServer } from "node:http";
 import { oauthErrorHtml, oauthSuccessHtml } from "../../utils/oauth-page.js";
+import { OAuthTokenEndpointError } from "../../utils/oauth-refresh-error.js";
 import { getProviderEnvValue } from "../../utils/provider-env.js";
 import { generatePKCE } from "./pkce.js";
 // every login registers a new client with this ID; OpenAI returns the issued client ID in the callback
@@ -119,7 +120,7 @@ async function requestToken(body, signal) {
     });
     if (!response.ok) {
         const responseBody = await response.text().catch(() => "");
-        throw new Error(`OpenAI OAuth token request failed (${response.status}): ${responseBody || response.statusText}`);
+        throw new OAuthTokenEndpointError(`OpenAI OAuth token request failed (${response.status}): ${responseBody || response.statusText}`, response.status);
     }
     const data = await response.json();
     if (typeof data !== "object" || data === null || Array.isArray(data)) {

package/dist/auth/oauth/openrouter.js

@@ -10,6 +10,7 @@
  * NOTE: This module uses node:http (via callback-server.ts) for the OAuth callback server.
  * It is only intended for CLI use, not browser environments.
  */
+import { OAuthTokenEndpointError } from "../../utils/oauth-refresh-error.js";
 import { getProviderEnvValue } from "../../utils/provider-env.js";
 import { startOAuthCallbackServer, waitForCallbackOrManualInput } from "./callback-server.js";
 import { generatePKCE } from "./pkce.js";
@@ -88,7 +89,7 @@ async function exchangeAuthorizationCode(code, verifier, signal) {
     }
     if (!response.ok) {
         const detail = errorDetail(body);
-        throw new Error(`OpenRouter OAuth key exchange failed (HTTP ${response.status})${detail ? `: ${detail}` : ""}`);
+        throw new OAuthTokenEndpointError(`OpenRouter OAuth key exchange failed (HTTP ${response.status})${detail ? `: ${detail}` : ""}`, response.status);
     }
     if (typeof body.key !== "string" || body.key.length === 0) {
         throw new Error('OpenRouter OAuth response carries no "key"');

package/dist/auth/oauth/radius.js

@@ -9,6 +9,7 @@
  * It is only intended for CLI use, not browser environments.
  */
 import { normalizeRadiusGatewayUrl } from "../../providers/radius-config.js";
+import { OAuthTokenEndpointError } from "../../utils/oauth-refresh-error.js";
 import { startOAuthCallbackServer } from "./callback-server.js";
 import { pollOAuthDeviceCodeFlow } from "./device-code.js";
 import { generatePKCE } from "./pkce.js";
@@ -36,15 +37,14 @@ async function loadRadiusOAuthDiscovery(gateway, signal) {
     }
     return { authorizationEndpoint: discovery.authorizationEndpoint };
 }
-class OAuthResponseError extends Error {
+class OAuthResponseError extends OAuthTokenEndpointError {
     constructor(status, oauthError, description, message) {
         const detail = oauthError
             ? description
                 ? `${oauthError}: ${description}`
                 : oauthError
             : description || String(status);
-        super(`${message}: ${detail}`);
-        this.status = status;
+        super(`${message}: ${detail}`, status);
         this.oauthError = oauthError;
     }
 }
@@ -76,7 +76,7 @@ async function requestOAuthToken(gateway, body, signal) {
     }
     catch (error) {
         if (signal.aborted) {
-            throw new Error("Login cancelled");
+            throw new Error("Login cancelled", { cause: signal.reason });
         }
         throw error;
     }
@@ -149,7 +149,7 @@ async function requestDeviceAuthorization(gateway, signal) {
     }
     catch (error) {
         if (signal.aborted) {
-            throw new Error("Login cancelled");
+            throw new Error("Login cancelled", { cause: signal.reason });
         }
         throw error;
     }