@code-yeongyu/senpi-ai 2026.10.31-2 → 2026.11.2-2

package/dist/types.d.ts

@@ -19,6 +19,12 @@ import type { AssistantMessageEventStream } from "./utils/event-stream.ts";
 export type { Model } from "./model.ts";
 export type { SessionAffinityFormat } from "./openai-responses-compat.ts";
 export type OpenAIResponsesCompat = BaseOpenAIResponsesCompat & {
+    /**
+     * The selected credential uses Sign in with ChatGPT plan usage on the public Responses API.
+     * Set per credential route, not by token prefix or provider id. Never set for API keys
+     * or the ChatGPT backend/Codex route.
+     */
+    siwc?: boolean;
     /**
      * Exact native search type for a compatible Responses endpoint.
      * OpenAI supports both names; xAI documents only web_search.

package/dist/utils/empty-response-errors.d.ts

@@ -10,6 +10,5 @@
  */
 export declare const EMPTY_RESPONSE_ERROR = "Model returned an empty response twice";
 export declare const EMPTY_TOOL_USE_ERROR = "Model returned tool_use without a tool call twice";
-export declare const FORWARDED_EMPTY_RESPONSE_ERROR = "Model returned an empty response after streaming thinking";
-export declare const FORWARDED_EMPTY_TOOL_USE_ERROR = "Model returned tool_use without a tool call after streaming thinking";
+export { FORWARDED_EMPTY_RESPONSE_ERROR, FORWARDED_EMPTY_TOOL_USE_ERROR } from "./retry.ts";
 //# sourceMappingURL=empty-response-errors.d.ts.map

package/dist/utils/empty-response-errors.js

@@ -10,6 +10,5 @@
  */
 export const EMPTY_RESPONSE_ERROR = "Model returned an empty response twice";
 export const EMPTY_TOOL_USE_ERROR = "Model returned tool_use without a tool call twice";
-export const FORWARDED_EMPTY_RESPONSE_ERROR = "Model returned an empty response after streaming thinking";
-export const FORWARDED_EMPTY_TOOL_USE_ERROR = "Model returned tool_use without a tool call after streaming thinking";
+export { FORWARDED_EMPTY_RESPONSE_ERROR, FORWARDED_EMPTY_TOOL_USE_ERROR } from "./retry.js";
 //# sourceMappingURL=empty-response-errors.js.map

package/dist/utils/oauth-refresh-error.d.ts

@@ -1,7 +1,14 @@
 import { ModelsError } from "./models-error.ts";
 export declare class OAuthTokenEndpointError extends Error {
     readonly status: number;
-    constructor(message: string, status: number);
+    /** The OAuth `error` code of the response body (RFC 6749 section 5.2), when the adapter read one. */
+    readonly oauthError?: string;
+    /** The adapter itself decided that the endpoint refused this credential, so it needs a new login. */
+    readonly credentialRefused: boolean;
+    constructor(message: string, status: number, facts?: {
+        oauthError?: string;
+        credentialRefused?: boolean;
+    });
 }
 /** Closed, log-safe facts only; never inspect the message or response body. */
 export declare function oauthRefreshFailureCause(error: unknown): string | undefined;

package/dist/utils/oauth-refresh-error.js

@@ -1,9 +1,11 @@
 var _a;
 import { ModelsError } from "./models-error.js";
 export class OAuthTokenEndpointError extends Error {
-    constructor(message, status) {
+    constructor(message, status, facts = {}) {
         super(message);
         this.status = status;
+        this.oauthError = facts.oauthError;
+        this.credentialRefused = facts.credentialRefused ?? false;
     }
 }
 const TRANSPORT_CODES = new Set([

package/dist/utils/provider-diagnostic-carrier.d.ts

@@ -1,5 +1,14 @@
-import type { ProviderDiagnostic } from "../provider-diagnostic.ts";
+import type { ProviderDiagnostic, ProviderDiagnosticCategory } from "../provider-diagnostic.ts";
+type SiwcRecovery = "usage_limit" | "account_disabled" | "auth" | "request" | "transient";
+export declare function siwcErrorForCode(code: string): {
+    readonly category: ProviderDiagnosticCategory;
+    readonly status: number;
+    readonly recovery: SiwcRecovery;
+} | undefined;
+/** Shared by HTTP retry, assistant retry, and the credential pool; unknown codes stay unknown. */
+export declare function siwcRecoveryFromDiagnostic(diagnostic: ProviderDiagnostic | undefined): SiwcRecovery | undefined;
 export declare function attachProviderDiagnostic<E extends object>(error: E, diagnostic: ProviderDiagnostic | undefined): E;
 /** Raw lookup; callers revalidate before exposing the value. */
 export declare function peekProviderDiagnostic(error: unknown): ProviderDiagnostic | undefined;
+export {};
 //# sourceMappingURL=provider-diagnostic-carrier.d.ts.map

package/dist/utils/provider-diagnostic-carrier.js

@@ -1,3 +1,38 @@
+/** Exact Responses codes, not prose: errors-and-recovery#structured-responses-errors. */
+const SIWC_ERRORS = {
+    subscription_sharing_usage_limit_exceeded: { category: "quota", status: 429, recovery: "usage_limit" },
+    subscription_sharing_user_not_eligible: { category: "unknown", status: 403, recovery: "account_disabled" },
+    subscription_sharing_usage_unavailable: { category: "provider_unavailable", status: 503, recovery: "transient" },
+    subscription_sharing_user_unavailable: { category: "provider_unavailable", status: 503, recovery: "transient" },
+    subscription_sharing_invalid_user: { category: "auth", status: 401, recovery: "auth" },
+    subscription_sharing_unsupported_capability: { category: "invalid_request", status: 400, recovery: "request" },
+    subscription_sharing_route_not_supported: { category: "invalid_request", status: 403, recovery: "request" },
+    chatpass_v2_scope_not_authorized: { category: "invalid_request", status: 403, recovery: "request" },
+    chatpass_v2_invalid_authorization_context: { category: "invalid_request", status: 403, recovery: "request" },
+};
+export function siwcErrorForCode(code) {
+    return Object.hasOwn(SIWC_ERRORS, code) ? SIWC_ERRORS[code] : undefined;
+}
+/** Shared by HTTP retry, assistant retry, and the credential pool; unknown codes stay unknown. */
+export function siwcRecoveryFromDiagnostic(diagnostic) {
+    if (diagnostic?.evidence === "structured_code" && diagnostic.code !== undefined) {
+        return siwcErrorForCode(diagnostic.code)?.recovery;
+    }
+    // A direct-admission detail body has no code. Route provenance is necessary here:
+    // a generic provider's 403 must retain its existing credential policy.
+    if (diagnostic?.route !== "siwc" || diagnostic.evidence !== "structured_status")
+        return undefined;
+    switch (diagnostic.httpStatus) {
+        case 401:
+            return "auth";
+        case 403:
+            return "request";
+        case 503:
+            return "transient";
+        default:
+            return undefined;
+    }
+}
 /**
  * Adapter-owned side channel for a diagnostic that rides along a thrown provider
  * error. The error keeps its exact message and identity; the diagnostic lives in

package/dist/utils/provider-diagnostic-sources.d.ts

@@ -16,6 +16,8 @@ export declare function anthropicProviderDiagnosticFromSseData(data: string): Pr
  * buckets that can contradict the precise code.
  */
 export declare function openAICompatibleProviderDiagnosticFromError(error: unknown): ProviderDiagnostic | undefined;
+/** SIWC transport boundary, including direct-admission {"detail": ...} bodies. */
+export declare function siwcProviderDiagnosticFromError(error: unknown): ProviderDiagnostic | undefined;
 export declare function transportProviderDiagnosticFromError(error: unknown): ProviderDiagnostic | undefined;
 /**
  * Await one provider transport call and, if it rejects, attach the classifier's

package/dist/utils/provider-diagnostic-sources.js

@@ -97,6 +97,11 @@ export function openAICompatibleProviderDiagnosticFromError(error) {
         return undefined;
     }
 }
+/** SIWC transport boundary, including direct-admission {"detail": ...} bodies. */
+export function siwcProviderDiagnosticFromError(error) {
+    const diagnostic = openAICompatibleProviderDiagnosticFromError(error);
+    return diagnostic === undefined ? undefined : { ...diagnostic, route: "siwc" };
+}
 /**
  * A connection failure carries no HTTP status; it proves only that the request got
  * no provider answer. Reads the error's own `code`, then `cause.code` (fetch

package/dist/utils/provider-diagnostic-vocabulary.d.ts

@@ -31,6 +31,7 @@ export declare function buildProviderDiagnostic(input: {
     code?: string;
     evidence: ProviderDiagnosticEvidence;
     resetsAt?: number;
+    route?: "siwc";
 }): ProviderDiagnostic | undefined;
 export interface ProviderFailureFacts {
     /** Status read from the transport error; `undefined` for an in-stream error. */

package/dist/utils/provider-diagnostic-vocabulary.js

@@ -1,3 +1,4 @@
+import { siwcErrorForCode } from "./provider-diagnostic-carrier.js";
 /** Serialized UTF-8 budget for one emitted diagnostic. */
 export const PROVIDER_DIAGNOSTIC_MAX_BYTES = 512;
 /**
@@ -8,6 +9,9 @@ export const PROVIDER_DIAGNOSTIC_MAX_BYTES = 512;
  * `billing_error` proves a billing failure, not quota exhaustion, so it stays `unknown`.
  */
 export function categoryForProviderCode(code) {
+    const siwc = siwcErrorForCode(code);
+    if (siwc !== undefined)
+        return siwc.category;
     switch (code) {
         case "authentication_error":
         case "invalid_api_key":
@@ -63,6 +67,9 @@ export function categoryForTransportCode(code) {
 }
 /** The HTTP status a recognized token may arrive with; anything else is contradictory evidence. */
 export function isProviderCodeStatusCompatible(code, status) {
+    const siwc = siwcErrorForCode(code);
+    if (siwc !== undefined)
+        return status === siwc.status;
     switch (code) {
         case "authentication_error":
         case "invalid_api_key":
@@ -142,6 +149,8 @@ export function buildProviderDiagnostic(input) {
         diagnostic.httpStatus = input.httpStatus;
     if (input.code !== undefined)
         diagnostic.code = input.code;
+    if (input.route !== undefined)
+        diagnostic.route = input.route;
     if (input.resetsAt !== undefined && (input.category === "quota" || input.category === "rate_limit"))
         diagnostic.resetsAt = input.resetsAt;
     const size = new TextEncoder().encode(JSON.stringify(diagnostic)).length;

package/dist/utils/provider-retry.js

@@ -1,4 +1,4 @@
-import { attachProviderDiagnostic, peekProviderDiagnostic } from "./provider-diagnostic-carrier.js";
+import { attachProviderDiagnostic, peekProviderDiagnostic, siwcRecoveryFromDiagnostic, } from "./provider-diagnostic-carrier.js";
 import { appendRetryAfterMsMarker, extract429RetryAfterMs } from "./retry-hint.js";
 const DEFAULT_MAX_RETRY_DELAY_MS = 60_000;
 const DIGITALOCEAN_STREAM_FAILURE_MESSAGE = "Upstream error from DigitalOcean: stream failed";
@@ -14,6 +14,9 @@ function isProviderError(error) {
 }
 /** Mirrors the pinned OpenAI/Anthropic SDK retry policy; review when either SDK is upgraded. */
 function isRetryableProviderError(error) {
+    const siwc = siwcRecoveryFromDiagnostic(peekProviderDiagnostic(error));
+    if (siwc !== undefined)
+        return siwc === "transient";
     const shouldRetry = error.headers?.get("x-should-retry");
     if (shouldRetry === "true")
         return true;

package/dist/utils/retry.d.ts

@@ -1,4 +1,6 @@
 import type { AssistantMessage } from "../types.ts";
+export declare const FORWARDED_EMPTY_RESPONSE_ERROR = "Model returned an empty response after streaming thinking";
+export declare const FORWARDED_EMPTY_TOOL_USE_ERROR = "Model returned tool_use without a tool call after streaming thinking";
 /**
  * Diagnostic type on a terminal assistant message whose request failed because an OAuth refresh failed
  * transiently (senpi#2893). Defined here, beside the classifier that reads it, so the retry entry graph

package/dist/utils/retry.js

@@ -1,4 +1,8 @@
-import { FORWARDED_EMPTY_RESPONSE_ERROR, FORWARDED_EMPTY_TOOL_USE_ERROR } from "./empty-response-errors.js";
+import { siwcRecoveryFromDiagnostic } from "./provider-diagnostic-carrier.js";
+// Owned beside their classifier so retry stays a two-file entry graph. The stream
+// wrapper's empty-response-errors entry re-exports these same terminal texts.
+export const FORWARDED_EMPTY_RESPONSE_ERROR = "Model returned an empty response after streaming thinking";
+export const FORWARDED_EMPTY_TOOL_USE_ERROR = "Model returned tool_use without a tool call after streaming thinking";
 /**
  * Diagnostic type on a terminal assistant message whose request failed because an OAuth refresh failed
  * transiently (senpi#2893). Defined here, beside the classifier that reads it, so the retry entry graph
@@ -102,8 +106,8 @@ const NON_RETRYABLE_PROVIDER_ERROR_PATTERN = buildProviderErrorPattern([
     "tools\\.[^ ]*function\\.parameters",
     "tools\\.\\d+\\.function\\.parameters",
     "invalid tool schema",
-    // Sign in with ChatGPT: the subscription's shared usage limit, which resets
-    // after hours rather than seconds.
+    // Legacy text-only SIWC failures. Structured diagnostics take precedence below;
+    // this code alone proves no reset time.
     "subscription_sharing_usage_limit_exceeded",
 ]);
 const RETRYABLE_PROVIDER_ERROR_PATTERN = buildProviderErrorPattern([
@@ -389,6 +393,13 @@ export async function retryAssistantCall(produce, policy, signal, callbacks) {
  * before restarting the assistant turn.
  */
 export function isRetryableAssistantError(message) {
+    const siwc = siwcRecoveryFromDiagnostic(message.providerDiagnostic);
+    if (siwc !== undefined &&
+        message.stopReason === "error" &&
+        message.stopDetails?.type !== "refusal" &&
+        message.stopDetails?.type !== "sensitive") {
+        return siwc === "transient";
+    }
     // A route that does not serve the model answers the same on every attempt, whatever status wraps it.
     if (message.errorCause?.type === "model_config")
         return false;

package/dist/utils/siwc-errors.d.ts

@@ -0,0 +1,2 @@
+export { siwcRecoveryFromDiagnostic } from "./provider-diagnostic-carrier.ts";
+//# sourceMappingURL=siwc-errors.d.ts.map

package/dist/utils/siwc-errors.js

@@ -0,0 +1,2 @@
+export { siwcRecoveryFromDiagnostic } from "./provider-diagnostic-carrier.js";
+//# sourceMappingURL=siwc-errors.js.map

package/dist/utils/tool-name-match.js

@@ -50,6 +50,51 @@ function uniqueMatch(names, matches) {
     const found = names.filter(matches);
     return found.length === 1 ? found[0] : undefined;
 }
+/**
+ * Words that turn a stray prefix into an instruction rather than noise: a call
+ * named `delete_write` or `force_bash` is refused, never run as `write` or
+ * `bash`.
+ */
+const DESTRUCTIVE_PREFIX_WORDS = new Set([
+    "delete",
+    "remove",
+    "rm",
+    "force",
+    "drop",
+    "purge",
+    "wipe",
+    "kill",
+    "reset",
+    "overwrite",
+    "truncate",
+    "destroy",
+]);
+/**
+ * Last resort for a plain name carrying a stray word prefix (`trophy_eval` for
+ * `eval`, omo#12065). The prefixes models emit there are arbitrary words a
+ * namespacing proxy invented (`trophy`, `fringe`, `board`, `column`), so the
+ * prefix cannot be allowlisted; instead it is refused when it carries meaning.
+ * Resolves to the one registered tool whose exact name is a `_`-separated
+ * suffix of the requested name, unless any word of the stripped prefix is a
+ * destructive verb (`delete_write`) or itself names a registered tool
+ * (`read_write`). Namespaced names are excluded so `mcp__sandbox__run_bash`
+ * still never falls through to a local `bash`, and two suffix matches
+ * (`x_read_file` against `read_file` and `file`) refuse.
+ */
+function strayPrefixMatch(requested, names) {
+    if (toolNameForms(requested).length > 1)
+        return undefined;
+    const match = uniqueMatch(names, (name) => requested.length > name.length + 1 && requested.endsWith(`_${name}`));
+    if (match === undefined)
+        return undefined;
+    const prefix = requested.slice(0, requested.length - match.length - 1);
+    const registered = new Set(names.map(foldToolName));
+    const meaningful = [prefix, ...prefix.split(/[-_]+/)].some((word) => {
+        const key = foldToolName(word);
+        return DESTRUCTIVE_PREFIX_WORDS.has(key) || registered.has(key);
+    });
+    return meaningful ? undefined : match;
+}
 /** Resolve `requested` to the one available tool it names, or `undefined` when none or several match. */
 export function resolveToolNameMatch(requested, available) {
     const names = [...new Set(available)];
@@ -66,6 +111,6 @@ export function resolveToolNameMatch(requested, available) {
         if (unprefixed !== undefined)
             return unprefixed;
     }
-    return undefined;
+    return strayPrefixMatch(requested, names);
 }
 //# sourceMappingURL=tool-name-match.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-ai",
-	"version": "2026.10.31-2",
+	"version": "2026.11.2-2",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -88,7 +88,7 @@
 	"dependencies": {
 		"@anthropic-ai/sdk": "0.127.0",
 		"@aws-sdk/client-bedrock-runtime": "3.1136.0",
-		"@earendil-works/pi-telemetry": "npm:@code-yeongyu/senpi-telemetry@2026.10.31-2",
+		"@earendil-works/pi-telemetry": "npm:@code-yeongyu/senpi-telemetry@2026.11.2-2",
 		"@google/genai": "2.23.0",
 		"@smithy/node-http-handler": "4.12.1",
 		"google-auth-library": "10.6.2",

package/dist/auth/pool/classify.d.ts

@@ -1,16 +0,0 @@
-export type PoolFailureAction = "rotate" | "retry" | "fail";
-export type PoolBlockReason = "auth_error" | "rate_limit";
-export type PoolFailureClassification = {
-    action: PoolFailureAction;
-    blockReason?: PoolBlockReason;
-    retryAfterMs?: number;
-};
-/**
- * Three-way in-lane failure taxonomy. Rotation is reserved for failures another
- * account can plausibly absorb (rate/capacity and per-account auth); transient
- * transport failures stay on the same slot for the outer retry policy, and
- * everything unrecognized default-denies to `fail` so the model fallback chain
- * above this engine keeps owning unknown errors.
- */
-export declare function classifyPoolFailure(error: unknown): PoolFailureClassification;
-//# sourceMappingURL=classify.d.ts.map

package/dist/auth/pool/classify.js

@@ -1,75 +0,0 @@
-const MAX_NESTING_DEPTH = 3;
-function fieldOf(value, key) {
-    if (typeof value !== "object" || value === null)
-        return undefined;
-    const entry = Object.entries(value).find(([candidate]) => candidate === key);
-    return entry?.[1];
-}
-function statusOf(error, depth = 0) {
-    if (depth >= MAX_NESTING_DEPTH)
-        return undefined;
-    for (const key of ["status", "statusCode"]) {
-        const value = fieldOf(error, key);
-        if (typeof value === "number")
-            return value;
-    }
-    const nested = fieldOf(error, "error");
-    return nested === undefined ? undefined : statusOf(nested, depth + 1);
-}
-function messageOf(error, depth = 0) {
-    if (typeof error === "string")
-        return error;
-    if (error instanceof Error)
-        return error.message;
-    if (depth >= MAX_NESTING_DEPTH)
-        return String(error);
-    const message = fieldOf(error, "message");
-    if (typeof message === "string")
-        return message;
-    const nested = fieldOf(error, "error");
-    return nested === undefined ? String(error) : messageOf(nested, depth + 1);
-}
-function retryAfterMsOf(error, text) {
-    const explicit = fieldOf(error, "retryAfterMs");
-    if (typeof explicit === "number" && Number.isFinite(explicit) && explicit > 0)
-        return Math.ceil(explicit);
-    const milliseconds = text.match(/\bretry[-_ ]?after[-_ ]?ms\s*[:=]\s*(\d+(?:\.\d+)?)/i);
-    if (milliseconds?.[1] !== undefined)
-        return Math.ceil(Number(milliseconds[1]));
-    const seconds = text.match(/\bretry[-_ ]?after\s*[:=]\s*(\d+(?:\.\d+)?)/i);
-    return seconds?.[1] === undefined ? undefined : Math.ceil(Number(seconds[1]) * 1_000);
-}
-const RATE_LIMIT_TEXT = /rate.?limit|resource_exhausted|quota|too many requests|overloaded/i;
-const AUTH_TEXT = /invalid.?api.?key|unauthorized|authentication|forbidden|token (?:is )?expired|revoked/i;
-const TRANSIENT_TEXT = /econnreset|econnrefused|etimedout|socket hang up|fetch failed|network error|internal server error|service unavailable|bad gateway|gateway timeout/i;
-function rotateOnRateLimit(error, text) {
-    const retryAfterMs = retryAfterMsOf(error, text);
-    return retryAfterMs === undefined
-        ? { action: "rotate", blockReason: "rate_limit" }
-        : { action: "rotate", blockReason: "rate_limit", retryAfterMs };
-}
-/**
- * Three-way in-lane failure taxonomy. Rotation is reserved for failures another
- * account can plausibly absorb (rate/capacity and per-account auth); transient
- * transport failures stay on the same slot for the outer retry policy, and
- * everything unrecognized default-denies to `fail` so the model fallback chain
- * above this engine keeps owning unknown errors.
- */
-export function classifyPoolFailure(error) {
-    const text = messageOf(error);
-    const status = statusOf(error);
-    if (status === 429 || status === 529)
-        return rotateOnRateLimit(error, text);
-    if (status === 401 || status === 403)
-        return { action: "rotate", blockReason: "auth_error" };
-    if (status !== undefined && status >= 500 && status < 600)
-        return { action: "retry" };
-    if (RATE_LIMIT_TEXT.test(text))
-        return rotateOnRateLimit(error, text);
-    if (AUTH_TEXT.test(text))
-        return { action: "rotate", blockReason: "auth_error" };
-    if (TRANSIENT_TEXT.test(text))
-        return { action: "retry" };
-    return { action: "fail" };
-}
-//# sourceMappingURL=classify.js.map