@code-yeongyu/senpi-ai 2026.10.10 → 2026.10.11

package/dist/providers/kimi-coding.models.d.ts

@@ -45,7 +45,7 @@ declare const values: {
                 readonly input: 3;
                 readonly output: 15;
                 readonly cacheRead: 0.3;
-                readonly cacheWrite: 0;
+                readonly cacheWrite: 3;
             };
             readonly contextWindow: 1048576;
             readonly maxTokens: 131072;

package/dist/providers/kimi-coding.models.js

@@ -44,7 +44,7 @@ const values = {
                 "input": 3,
                 "output": 15,
                 "cacheRead": 0.3,
-                "cacheWrite": 0
+                "cacheWrite": 3
             },
             "contextWindow": 1048576,
             "maxTokens": 131072

package/dist/providers/opengateway-refresh.js

@@ -10,6 +10,7 @@
 //
 // Any fetch or parse failure keeps the last good list and surfaces as a refresh error.
 import { isModelType } from "../utils/model-operations.js";
+import { OAuthTokenEndpointError } from "../utils/oauth-refresh-error.js";
 import { applyOpenAiInputCap } from "../utils/openai-input-cap.js";
 import { isServableChatModel, OPENGATEWAY_BASE_URL, OPENGATEWAY_MODELS_URL, OPENGATEWAY_PRICES_URL, openGatewayPrice, parseOpenGatewayListing, parseOpenGatewayPriceTable, servingTierBase, withGatewayPrice, } from "./opengateway-catalog.js";
 export const OPENGATEWAY_REFRESH_INTERVAL_MS = 60 * 60 * 1000;
@@ -67,7 +68,7 @@ export function overlayOpenGatewayCatalog(shipped, listing, prices) {
 async function fetchJson(url, signal) {
     const response = await fetch(url, { headers: { accept: "application/json" }, signal });
     if (!response.ok)
-        throw new Error(`OpenGateway catalog request failed: ${url} returned ${response.status}`);
+        throw new OAuthTokenEndpointError(`OpenGateway catalog request failed: ${url} returned ${response.status}`, response.status);
     return response.json();
 }
 async function fetchRefreshedCatalog(shipped, signal) {

package/dist/types.d.ts

@@ -690,8 +690,9 @@ export interface Context {
     tools?: Tool[];
     /**
      * Names from `tools` the model may call on this request; absent means every tool is callable.
-     * Set only for models whose compat declares `supportsAllowedTools`: the adapter keeps `tools`
-     * byte-stable and restricts callability through `tool_choice` (senpi#2095).
+     * Set only for models that `supportsAllowedToolChoice` accepts (the compat flag on a native OpenAI API
+     * host): the adapter keeps `tools` byte-stable and restricts callability through `tool_choice`
+     * (senpi#2095, senpi#3080).
      */
     activeToolNames?: string[];
 }

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

@@ -0,0 +1,16 @@
+import { ModelsError } from "./models-error.ts";
+export declare class OAuthTokenEndpointError extends Error {
+    readonly status: number;
+    constructor(message: string, status: number);
+}
+/** Closed, log-safe facts only; never inspect the message or response body. */
+export declare function oauthRefreshFailureCause(error: unknown): string | undefined;
+export declare function classifyOAuthRefreshFailure(error: unknown): "transient" | "permanent";
+declare const UNAVAILABLE: unique symbol;
+export declare class OAuthRefreshUnavailableError extends ModelsError {
+    readonly [UNAVAILABLE] = true;
+    constructor(provider: string, cause: unknown);
+}
+export declare function isOAuthRefreshUnavailableError(error: unknown): error is OAuthRefreshUnavailableError;
+export {};
+//# sourceMappingURL=oauth-refresh-error.d.ts.map

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

@@ -0,0 +1,67 @@
+var _a;
+import { ModelsError } from "./models-error.js";
+export class OAuthTokenEndpointError extends Error {
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+    }
+}
+const TRANSPORT_CODES = new Set([
+    "ConnectionRefused",
+    "FailedToOpenSocket",
+    "ConnectionClosed",
+    "ECONNREFUSED",
+    "ECONNRESET",
+    "ENOTFOUND",
+    "EAI_AGAIN",
+    "ETIMEDOUT",
+    "EPIPE",
+    "UND_ERR_CONNECT_TIMEOUT",
+    "UND_ERR_HEADERS_TIMEOUT",
+    "UND_ERR_BODY_TIMEOUT",
+    "UND_ERR_SOCKET",
+]);
+/** Both cause walks are bounded as well as cycle-safe: a refresh failure's cause chain is a few links deep. */
+const MAX_CAUSE_LINKS = 16;
+/** Closed, log-safe facts only; never inspect the message or response body. */
+export function oauthRefreshFailureCause(error) {
+    const seen = new Set();
+    while (typeof error === "object" && error !== null && !seen.has(error) && seen.size < MAX_CAUSE_LINKS) {
+        seen.add(error);
+        if (Reflect.get(error, "name") === "TimeoutError")
+            return "timeout";
+        const code = Reflect.get(error, "code");
+        if (typeof code === "string" && TRANSPORT_CODES.has(code)) {
+            return code === "ConnectionRefused" || code === "ECONNREFUSED" ? "connection_refused" : code.toLowerCase();
+        }
+        const status = Reflect.get(error, "status");
+        if (typeof status === "number" && (status === 408 || status === 429 || (status >= 500 && status < 600))) {
+            return `http_${status}`;
+        }
+        error = Reflect.get(error, "cause");
+    }
+    return undefined;
+}
+export function classifyOAuthRefreshFailure(error) {
+    return oauthRefreshFailureCause(error) === undefined ? "permanent" : "transient";
+}
+const UNAVAILABLE = Symbol.for("senpi.oauthRefreshUnavailable");
+export class OAuthRefreshUnavailableError extends ModelsError {
+    static { _a = UNAVAILABLE; }
+    constructor(provider, cause) {
+        super("oauth", `OAuth refresh failed for ${provider}`, { cause });
+        this[_a] = true;
+        this.name = "OAuthRefreshUnavailableError";
+    }
+}
+export function isOAuthRefreshUnavailableError(error) {
+    const seen = new Set();
+    while (typeof error === "object" && error !== null && !seen.has(error) && seen.size < MAX_CAUSE_LINKS) {
+        seen.add(error);
+        if (Reflect.get(error, UNAVAILABLE) === true)
+            return true;
+        error = Reflect.get(error, "cause");
+    }
+    return false;
+}
+//# sourceMappingURL=oauth-refresh-error.js.map

package/dist/utils/prompt-cache-ttl.js

@@ -36,7 +36,9 @@ const FORCED_TOOL_CHOICE_REJECTING_MODEL_ID = /^claude-(?:(?:fable|mythos)(?:-|$
 /**
  * Default for `supportsToolReferences`: first-party Anthropic models except
  * Haiku (rejects client-side tool_reference blocks) and models that predate
- * tool search (Claude 3.x, Opus/Sonnet 4.0, Opus 4.1).
+ * tool search (Claude 3.x, Opus/Sonnet 4.0, Opus 4.1). Haiku 5.5 is listed in
+ * Anthropic's tool-search table, as Haiku 4.5 is, but stays off until a live
+ * probe confirms it (senpi#2914).
  */
 function defaultSupportsToolReferences(model) {
     if (model.provider !== "anthropic" || model.id.includes("haiku"))

package/dist/utils/retry.d.ts

@@ -1,4 +1,10 @@
 import type { AssistantMessage } from "../types.ts";
+/**
+ * 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
+ * stays free of the OAuth error types.
+ */
+export declare const OAUTH_REFRESH_UNAVAILABLE_DIAGNOSTIC = "oauth_refresh_unavailable";
 export declare const PROVIDER_REQUEST_ID_MARKER = "request id:";
 export declare function formatProviderRequestId(label: string, id: string): string;
 export declare function stripProviderRequestIds(text: string): string;

package/dist/utils/retry.js

@@ -1,4 +1,10 @@
 import { FORWARDED_EMPTY_RESPONSE_ERROR, FORWARDED_EMPTY_TOOL_USE_ERROR } from "./empty-response-errors.js";
+/**
+ * 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
+ * stays free of the OAuth error types.
+ */
+export const OAUTH_REFRESH_UNAVAILABLE_DIAGNOSTIC = "oauth_refresh_unavailable";
 // A provider's support request id is opaque hex like `C6FD:AB660:AEB5548:6ABA4D81`.
 // It can contain `429` or `500`, which message classifiers read as HTTP statuses,
 // so every id is rendered behind this marker and removed before classification.
@@ -371,6 +377,10 @@ export async function retryAssistantCall(produce, policy, signal, callbacks) {
  * before restarting the assistant turn.
  */
 export function isRetryableAssistantError(message) {
+    if (message.stopReason === "error" &&
+        message.diagnostics?.some((diagnostic) => diagnostic.type === OAUTH_REFRESH_UNAVAILABLE_DIAGNOSTIC)) {
+        return true;
+    }
     if (message.stopReason !== "error" ||
         message.stopDetails?.type === "refusal" ||
         message.stopDetails?.type === "sensitive" ||

package/dist/utils/tool-choice-fallback.d.ts

@@ -1,6 +1,17 @@
 import type { Api, Model } from "../types.ts";
 /** The wire identity a forced tool_choice refusal is remembered under. */
 export type ForcedToolChoiceTarget = Pick<Model<Api>, "api" | "provider" | "baseUrl" | "id">;
+/**
+ * A request refusal: the HTTP 400 that rejects the request, or the same refusal a gateway that has
+ * already answered 200 (a keepalive stream) sends in-band before any content (senpi#2801).
+ */
+export declare function isRequestRefusal(error: unknown): boolean;
+/**
+ * Reads `stream` until it has produced content (or ended, or `maxBuffered` contentless events went
+ * by), so a refusal a gateway sends in-band after answering 200 is raised while the request can still
+ * be retried. Such an error is marked as a request refusal; the events read are replayed in order.
+ */
+export declare function primeStreamUntilContent<T>(stream: AsyncIterable<T>, hasContent: (event: T) => boolean, maxBuffered?: number): Promise<AsyncIterable<T>>;
 export declare function isForcedToolChoiceUnsupportedError(error: unknown, sentForcedToolChoice: boolean): boolean;
 /**
  * A 400 to a request that forced a tool and whose message names that very tool: its `tools.N` /

package/dist/utils/tool-choice-fallback.js

@@ -30,8 +30,75 @@ function errorMessage(error) {
     }
     return String(error);
 }
+/** Marks an error a stream raised in-band, after its 200 response but before any content (senpi#2801). */
+const IN_BAND_BEFORE_CONTENT = Symbol.for("senpi.forcedToolChoice.inBandBeforeContent");
+function isInBandBeforeContent(error) {
+    return isRecord(error) && error[IN_BAND_BEFORE_CONTENT] === true;
+}
+function markInBandBeforeContent(error) {
+    const marked = isRecord(error) ? error : new Error(errorMessage(error));
+    try {
+        Object.defineProperty(marked, IN_BAND_BEFORE_CONTENT, { value: true });
+    }
+    catch {
+        // A frozen error keeps its own identity; it is then judged like any other in-band error.
+    }
+    return marked;
+}
+/**
+ * A request refusal: the HTTP 400 that rejects the request, or the same refusal a gateway that has
+ * already answered 200 (a keepalive stream) sends in-band before any content (senpi#2801).
+ */
+export function isRequestRefusal(error) {
+    const status = extractHttpStatus(error);
+    return status === 400 || (status === undefined && isInBandBeforeContent(error));
+}
+/**
+ * Reads `stream` until it has produced content (or ended, or `maxBuffered` contentless events went
+ * by), so a refusal a gateway sends in-band after answering 200 is raised while the request can still
+ * be retried. Such an error is marked as a request refusal; the events read are replayed in order.
+ */
+export async function primeStreamUntilContent(stream, hasContent, maxBuffered = 64) {
+    const iterator = stream[Symbol.asyncIterator]();
+    const buffered = [];
+    let ended = false;
+    try {
+        while (buffered.length < maxBuffered) {
+            const next = await iterator.next();
+            if (next.done) {
+                ended = true;
+                break;
+            }
+            buffered.push(next.value);
+            if (hasContent(next.value))
+                break;
+        }
+    }
+    catch (error) {
+        throw markInBandBeforeContent(error);
+    }
+    return {
+        async *[Symbol.asyncIterator]() {
+            try {
+                yield* buffered;
+                if (ended)
+                    return;
+                while (true) {
+                    const next = await iterator.next();
+                    if (next.done)
+                        return;
+                    yield next.value;
+                }
+            }
+            finally {
+                if (!ended)
+                    await iterator.return?.();
+            }
+        },
+    };
+}
 export function isForcedToolChoiceUnsupportedError(error, sentForcedToolChoice) {
-    if (!sentForcedToolChoice || extractHttpStatus(error) !== 400) {
+    if (!sentForcedToolChoice || !isRequestRefusal(error)) {
         return false;
     }
     const message = errorMessage(error);
@@ -77,7 +144,7 @@ function escapeRegExp(text) {
  * no tool, or another one, is not this refusal.
  */
 export function refusalNamesForcedTool(error, params) {
-    if (extractHttpStatus(error) !== 400)
+    if (!isRequestRefusal(error))
         return false;
     const name = forcedToolName(params.tool_choice);
     if (name === undefined)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-ai",
-	"version": "2026.10.10",
+	"version": "2026.10.11",
 	"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.10",
+		"@earendil-works/pi-telemetry": "npm:@code-yeongyu/senpi-telemetry@2026.10.11",
 		"@google/genai": "2.23.0",
 		"@smithy/node-http-handler": "4.12.1",
 		"http-proxy-agent": "9.1.0",