@code-yeongyu/senpi-ai 2026.10.9 → 2026.10.10-3

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

@@ -1,6 +1,12 @@
 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">;
+/**
+ * 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).
+ */
+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.9",
+	"version": "2026.10.10-3",
 	"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.9",
+		"@earendil-works/pi-telemetry": "npm:@code-yeongyu/senpi-telemetry@2026.10.10-3",
 		"@google/genai": "2.23.0",
 		"@smithy/node-http-handler": "4.12.1",
 		"http-proxy-agent": "9.1.0",