@oh-my-pi/pi-ai 13.5.2 → 13.5.4

package/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## [Unreleased]
 
+## [13.5.3] - 2026-03-01
+### Fixed
+
+- Fixed tool argument coercion to handle malformed JSON with trailing wrapper braces by parsing leading JSON containers
+
 ## [13.4.0] - 2026-03-01
 
 ### Breaking Changes

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "13.5.2",
+	"version": "13.5.4",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -41,7 +41,7 @@
 		"@aws-sdk/client-bedrock-runtime": "^3.998",
 		"@bufbuild/protobuf": "^2.11",
 		"@google/genai": "^1.43",
-		"@oh-my-pi/pi-utils": "13.5.2",
+		"@oh-my-pi/pi-utils": "13.5.4",
 		"@sinclair/typebox": "^0.34",
 		"@smithy/node-http-handler": "^4.4",
 		"ajv": "^8.18",

package/src/index.ts

@@ -19,6 +19,7 @@ export * from "./providers/kimi";
 export * from "./providers/openai-completions";
 export * from "./providers/openai-responses";
 export * from "./providers/synthetic";
+export * from "./rate-limit-utils";
 export * from "./stream";
 export * from "./types";
 export * from "./usage";

package/src/providers/google-gemini-cli.ts

@@ -22,6 +22,7 @@ import { AssistantMessageEventStream } from "../utils/event-stream";
 import { appendRawHttpRequestDumpFor400, type RawHttpRequestDump, withHttpStatus } from "../utils/http-inspector";
 import { refreshAntigravityToken } from "../utils/oauth/google-antigravity";
 import { refreshGoogleCloudToken } from "../utils/oauth/google-gemini-cli";
+import { extractHttpStatusFromError } from "../utils/retry";
 import {
 	convertMessages,
 	convertTools,
@@ -529,6 +530,12 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 
 					// Handle 429 rate limits with time budget
 					if (response.status === 429) {
+						if (/quota|exhausted/i.test(errorText)) {
+							throw withHttpStatus(
+								new Error(`Cloud Code Assist API error (429): ${extractErrorMessage(errorText)}`),
+								429,
+							);
+						}
 						const serverDelay = extractRetryDelay(errorText, response);
 						if (serverDelay && rateLimitTimeSpent + serverDelay <= RATE_LIMIT_BUDGET_MS) {
 							rateLimitTimeSpent += serverDelay;
@@ -549,8 +556,11 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 						const maxDelayMs = options?.maxRetryDelayMs ?? 60000;
 						if (maxDelayMs > 0 && serverDelay && serverDelay > maxDelayMs) {
 							const delaySeconds = Math.ceil(serverDelay / 1000);
-							throw new Error(
-								`Server requested ${delaySeconds}s retry delay (max: ${Math.ceil(maxDelayMs / 1000)}s). ${extractErrorMessage(errorText)}`,
+							throw withHttpStatus(
+								new Error(
+									`Server requested ${delaySeconds}s retry delay (max: ${Math.ceil(maxDelayMs / 1000)}s). ${extractErrorMessage(errorText)}`,
+								),
+								response.status,
 							);
 						}
 
@@ -570,6 +580,12 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 							throw new Error("Request was aborted");
 						}
 					}
+
+					// HTTP responses are handled inside the try block.
+					// If we intentionally throw with status metadata, don't convert it into a network retry.
+					if (extractHttpStatusFromError(error) !== undefined) {
+						throw error;
+					}
 					// Extract detailed error message from fetch errors (Node includes cause)
 					lastError = error instanceof Error ? error : new Error(String(error));
 					if (lastError.message === "fetch failed" && lastError.cause instanceof Error) {

package/src/rate-limit-utils.ts

@@ -0,0 +1,76 @@
+/**
+ * Rate limit reason classification and backoff calculation utilities.
+ * Ported from opencode-antigravity-auth plugin for consistency.
+ */
+
+export type RateLimitReason =
+	| "QUOTA_EXHAUSTED"
+	| "RATE_LIMIT_EXCEEDED"
+	| "MODEL_CAPACITY_EXHAUSTED"
+	| "SERVER_ERROR"
+	| "UNKNOWN";
+
+const QUOTA_EXHAUSTED_BACKOFF_MS = 30 * 60 * 1000; // 30 min
+const RATE_LIMIT_EXCEEDED_BACKOFF_MS = 30 * 1000; // 30s
+const MODEL_CAPACITY_BASE_MS = 45 * 1000; // 45s base
+const MODEL_CAPACITY_JITTER_MS = 30 * 1000; // ±15s
+const SERVER_ERROR_BACKOFF_MS = 20 * 1000; // 20s
+
+/**
+ * Classify a rate-limit error message into a reason category.
+ * Priority order: MODEL_CAPACITY > RATE_LIMIT > QUOTA > SERVER_ERROR > UNKNOWN.
+ *
+ * "resource exhausted" maps to MODEL_CAPACITY (transient, short wait)
+ * "quota exceeded" maps to QUOTA_EXHAUSTED (long wait, switch account)
+ */
+export function parseRateLimitReason(errorMessage: string): RateLimitReason {
+	const lower = errorMessage.toLowerCase();
+
+	if (
+		lower.includes("capacity") ||
+		lower.includes("overloaded") ||
+		lower.includes("529") ||
+		lower.includes("503") ||
+		lower.includes("resource exhausted")
+	) {
+		return "MODEL_CAPACITY_EXHAUSTED";
+	}
+
+	if (
+		lower.includes("per minute") ||
+		lower.includes("rate limit") ||
+		lower.includes("too many requests") ||
+		lower.includes("presque")
+	) {
+		return "RATE_LIMIT_EXCEEDED";
+	}
+
+	if (lower.includes("exhausted") || lower.includes("quota")) {
+		return "QUOTA_EXHAUSTED";
+	}
+
+	if (lower.includes("500") || lower.includes("internal error") || lower.includes("internal server error")) {
+		return "SERVER_ERROR";
+	}
+
+	return "UNKNOWN";
+}
+
+/**
+ * Calculate backoff delay in ms for a given rate limit reason.
+ * MODEL_CAPACITY gets jitter to prevent thundering herd.
+ */
+export function calculateRateLimitBackoffMs(reason: RateLimitReason): number {
+	switch (reason) {
+		case "QUOTA_EXHAUSTED":
+			return QUOTA_EXHAUSTED_BACKOFF_MS;
+		case "RATE_LIMIT_EXCEEDED":
+			return RATE_LIMIT_EXCEEDED_BACKOFF_MS;
+		case "MODEL_CAPACITY_EXHAUSTED":
+			return MODEL_CAPACITY_BASE_MS + Math.random() * MODEL_CAPACITY_JITTER_MS;
+		case "SERVER_ERROR":
+			return SERVER_ERROR_BACKOFF_MS;
+		default:
+			return QUOTA_EXHAUSTED_BACKOFF_MS; // conservative default
+	}
+}

package/src/utils/validation.ts

@@ -89,6 +89,55 @@ function tryParseNumberString(value: string, expectedTypes: string[]): { value:
 	return { value: parsed, changed: true };
 }
 
+function tryParseLeadingJsonContainer(value: string): unknown | undefined {
+	const firstChar = value[0];
+	const closingChar = firstChar === "{" ? "}" : firstChar === "[" ? "]" : undefined;
+	if (!closingChar) return undefined;
+
+	let depth = 0;
+	let inString = false;
+	let escaped = false;
+
+	for (let index = 0; index < value.length; index += 1) {
+		const char = value[index];
+
+		if (inString) {
+			if (escaped) {
+				escaped = false;
+				continue;
+			}
+			if (char === "\\") {
+				escaped = true;
+				continue;
+			}
+			if (char === '"') inString = false;
+			continue;
+		}
+
+		if (char === '"') {
+			inString = true;
+			continue;
+		}
+
+		if (char === firstChar) {
+			depth += 1;
+			continue;
+		}
+
+		if (char !== closingChar) continue;
+		depth -= 1;
+		if (depth !== 0) continue;
+
+		try {
+			return JSON.parse(value.slice(0, index + 1)) as unknown;
+		} catch {
+			return undefined;
+		}
+	}
+
+	return undefined;
+}
+
 /**
  * Attempts to parse a string as JSON if it looks like a JSON literal and
  * the parsed result matches one of the expected types.
@@ -112,8 +161,8 @@ function tryParseJsonForTypes(value: string, expectedTypes: string[]): { value:
 	}
 
 	// Quick syntactic checks to avoid unnecessary parse attempts
-	const looksJsonObject = trimmed.startsWith("{") && trimmed.endsWith("}");
-	const looksJsonArray = trimmed.startsWith("[") && trimmed.endsWith("]");
+	const looksJsonObject = trimmed.startsWith("{");
+	const looksJsonArray = trimmed.startsWith("[");
 	const looksJsonLiteral =
 		trimmed === "true" || trimmed === "false" || trimmed === "null" || JSON_NUMBER_PATTERN.test(trimmed);
 
@@ -128,7 +177,12 @@ function tryParseJsonForTypes(value: string, expectedTypes: string[]): { value:
 			return { value: parsed, changed: true };
 		}
 	} catch {
-		// Invalid JSON - leave as-is
+		if (looksJsonObject || looksJsonArray) {
+			const parsed = tryParseLeadingJsonContainer(trimmed);
+			if (parsed !== undefined && matchesExpectedType(parsed, expectedTypes)) {
+				return { value: parsed, changed: true };
+			}
+		}
 		return { value, changed: false };
 	}