gsd-pi 2.82.0-dev.9d5798940 → 2.82.0-dev.dfbc5f58f

package/packages/pi-ai/src/providers/openai-codex-responses.ts

@@ -89,6 +89,94 @@ function isRetryableError(status: number, errorText: string): boolean {
 	return /rate.?limit|overloaded|service.?unavailable|upstream.?connect|connection.?refused/i.test(errorText);
 }
 
+function extractRetryDelay(errorText: string, response?: Response | Headers): number | undefined {
+	const normalizeDelay = (ms: number): number | undefined => (ms > 0 ? Math.ceil(ms) : undefined);
+
+	const headers = response instanceof Headers ? response : response?.headers;
+	if (headers) {
+		const retryAfter = headers.get("retry-after");
+		if (retryAfter) {
+			const retryAfterSeconds = Number(retryAfter);
+			if (Number.isFinite(retryAfterSeconds)) {
+				const delay = normalizeDelay(retryAfterSeconds * 1000);
+				if (delay !== undefined) {
+					return delay;
+				}
+			}
+
+			const retryAfterDate = new Date(retryAfter).getTime();
+			if (!Number.isNaN(retryAfterDate)) {
+				const delay = normalizeDelay(retryAfterDate - Date.now());
+				if (delay !== undefined) {
+					return delay;
+				}
+			}
+		}
+
+		const rateLimitReset = headers.get("x-ratelimit-reset");
+		if (rateLimitReset) {
+			const resetSeconds = Number.parseInt(rateLimitReset, 10);
+			if (!Number.isNaN(resetSeconds)) {
+				const delay = normalizeDelay(resetSeconds * 1000 - Date.now());
+				if (delay !== undefined) {
+					return delay;
+				}
+			}
+		}
+
+		const rateLimitResetAfter = headers.get("x-ratelimit-reset-after");
+		if (rateLimitResetAfter) {
+			const resetAfterSeconds = Number(rateLimitResetAfter);
+			if (Number.isFinite(resetAfterSeconds)) {
+				const delay = normalizeDelay(resetAfterSeconds * 1000);
+				if (delay !== undefined) {
+					return delay;
+				}
+			}
+		}
+	}
+
+	const durationMatch = errorText.match(/reset after (?:(\d+)h)?(?:(\d+)m)?(\d+(?:\.\d+)?)s/i);
+	if (durationMatch) {
+		const hours = durationMatch[1] ? parseInt(durationMatch[1], 10) : 0;
+		const minutes = durationMatch[2] ? parseInt(durationMatch[2], 10) : 0;
+		const seconds = parseFloat(durationMatch[3]);
+		if (!Number.isNaN(seconds)) {
+			const totalMs = ((hours * 60 + minutes) * 60 + seconds) * 1000;
+			const delay = normalizeDelay(totalMs);
+			if (delay !== undefined) {
+				return delay;
+			}
+		}
+	}
+
+	const retryInMatch = errorText.match(/Please retry in ([0-9.]+)(ms|s)/i);
+	if (retryInMatch?.[1]) {
+		const value = parseFloat(retryInMatch[1]);
+		if (!Number.isNaN(value) && value > 0) {
+			const ms = retryInMatch[2].toLowerCase() === "ms" ? value : value * 1000;
+			const delay = normalizeDelay(ms);
+			if (delay !== undefined) {
+				return delay;
+			}
+		}
+	}
+
+	const retryDelayMatch = errorText.match(/"retryDelay":\s*"([0-9.]+)(ms|s)"/i);
+	if (retryDelayMatch?.[1]) {
+		const value = parseFloat(retryDelayMatch[1]);
+		if (!Number.isNaN(value) && value > 0) {
+			const ms = retryDelayMatch[2].toLowerCase() === "ms" ? value : value * 1000;
+			const delay = normalizeDelay(ms);
+			if (delay !== undefined) {
+				return delay;
+			}
+		}
+	}
+
+	return undefined;
+}
+
 function sleep(ms: number, signal?: AbortSignal): Promise<void> {
 	return new Promise((resolve, reject) => {
 		if (signal?.aborted) {
@@ -205,7 +293,9 @@ export const streamOpenAICodexResponses: StreamFunction<"openai-codex-responses"
 
 					const errorText = await response.text();
 					if (attempt < MAX_RETRIES && isRetryableError(response.status, errorText)) {
-						const delayMs = BASE_DELAY_MS * 2 ** attempt;
+						const backoffMs = BASE_DELAY_MS * 2 ** attempt;
+						const serverDelayMs = extractRetryDelay(errorText, response);
+						const delayMs = Math.max(backoffMs, serverDelayMs ?? 0);
 						await sleep(delayMs, options?.signal);
 						continue;
 					}

package/packages/pi-ai/src/providers/simple-options.test.ts

@@ -0,0 +1,60 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import { buildBaseOptions, defaultMaxTokens } from "./simple-options.js";
+import type { Api, Model } from "../types.js";
+
+function makeModel(overrides: Partial<Model<Api>> = {}): Model<Api> {
+	return {
+		id: "test-model",
+		name: "Test Model",
+		api: "bedrock-converse-stream",
+		provider: "amazon-bedrock",
+		baseUrl: "",
+		reasoning: false,
+		input: ["text"],
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+		contextWindow: 16384,
+		maxTokens: 16384,
+		...overrides,
+	};
+}
+
+describe("defaultMaxTokens", () => {
+	test("leaves prompt room when a non-Anthropic model declares output equal to context", () => {
+		const model = makeModel({
+			id: "qwen.qwen3-32b-v1:0",
+			contextWindow: 16384,
+			maxTokens: 16384,
+		});
+
+		assert.equal(defaultMaxTokens(model), 8192);
+	});
+
+	test("preserves smaller declared output windows", () => {
+		const model = makeModel({
+			contextWindow: 32000,
+			maxTokens: 8192,
+		});
+
+		assert.equal(defaultMaxTokens(model), 8192);
+	});
+
+	test("keeps the native Anthropic 32k ceiling within the context cap", () => {
+		const model = makeModel({
+			api: "anthropic-messages",
+			provider: "anthropic",
+			contextWindow: 200000,
+			maxTokens: 64000,
+		});
+
+		assert.equal(defaultMaxTokens(model), 32000);
+	});
+
+	test("honors explicit maxTokens", () => {
+		const model = makeModel();
+		const options = buildBaseOptions(model, { maxTokens: 12000 });
+
+		assert.equal(options.maxTokens, 12000);
+	});
+});

package/packages/pi-ai/src/providers/simple-options.ts

@@ -4,16 +4,15 @@ import type { Api, Model, SimpleStreamOptions, StreamOptions, ThinkingBudgets, T
  * Compute the default maxTokens for a model when no explicit value is provided.
  *
  * The 32 k cap is retained only for native Anthropic models (api === "anthropic-messages")
- * where the Anthropic API historically rejected higher values. Custom and
- * Anthropic-compatible models (e.g. OpenAI-completions, Vertex, etc.) use their
- * declared model.maxTokens directly so that providers with larger output windows
- * (131 072 tokens, etc.) are not silently capped.
+ * where the Anthropic API historically rejected higher values. Defaults also
+ * leave at least half the context window available for prompts.
  */
 export function defaultMaxTokens(model: Model<Api>): number {
+	const contextCappedMaxTokens = Math.max(1, Math.floor(model.contextWindow / 2));
 	if (model.api === "anthropic-messages") {
-		return Math.min(model.maxTokens, 32000);
+		return Math.min(model.maxTokens, 32000, contextCappedMaxTokens);
 	}
-	return model.maxTokens;
+	return Math.min(model.maxTokens, contextCappedMaxTokens);
 }
 
 export function buildBaseOptions(model: Model<Api>, options?: SimpleStreamOptions, apiKey?: string): StreamOptions {