@oh-my-pi/pi-ai 6.9.69 → 8.0.0

package/src/providers/openai-completions.ts

@@ -8,8 +8,8 @@ import type {
 	ChatCompletionMessageParam,
 	ChatCompletionToolMessageParam,
 } from "openai/resources/chat/completions";
-import { calculateCost } from "../models";
-import { getEnvApiKey } from "../stream";
+import { calculateCost } from "$ai/models";
+import { getEnvApiKey } from "$ai/stream";
 import type {
 	AssistantMessage,
 	Context,
@@ -23,11 +23,12 @@ import type {
 	ThinkingContent,
 	Tool,
 	ToolCall,
-} from "../types";
-import { AssistantMessageEventStream } from "../utils/event-stream";
-import { parseStreamingJson } from "../utils/json-parse";
-import { formatErrorMessageWithRetryAfter } from "../utils/retry-after";
-import { sanitizeSurrogates } from "../utils/sanitize-unicode";
+	ToolResultMessage,
+} from "$ai/types";
+import { AssistantMessageEventStream } from "$ai/utils/event-stream";
+import { parseStreamingJson } from "$ai/utils/json-parse";
+import { formatErrorMessageWithRetryAfter } from "$ai/utils/retry-after";
+import { sanitizeSurrogates } from "$ai/utils/sanitize-unicode";
 import { transformMessages } from "./transform-messages";
 
 /**
@@ -464,7 +465,7 @@ function maybeAddOpenRouterAnthropicCacheControl(
 	}
 }
 
-function convertMessages(
+export function convertMessages(
 	model: Model<"openai-completions">,
 	context: Context,
 	compat: Required<OpenAICompat>,
@@ -481,7 +482,8 @@ function convertMessages(
 
 	let lastRole: string | null = null;
 
-	for (const msg of transformedMessages) {
+	for (let i = 0; i < transformedMessages.length; i++) {
+		const msg = transformedMessages[i];
 		// Some providers (e.g. Mistral/Devstral) don't allow user messages directly after tool results
 		// Insert a synthetic assistant message to bridge the gap
 		if (compat.requiresAssistantAfterToolResult && lastRole === "toolResult" && msg.role === "user") {
@@ -605,55 +607,73 @@ function convertMessages(
 			}
 			params.push(assistantMsg);
 		} else if (msg.role === "toolResult") {
-			// Extract text and image content
-			const textResult = msg.content
-				.filter((c) => c.type === "text")
-				.map((c) => (c as any).text)
-				.join("\n");
-			const hasImages = msg.content.some((c) => c.type === "image");
-
-			// Always send tool result with text (or placeholder if only images)
-			const hasText = textResult.length > 0;
-			// Some providers (e.g. Mistral) require the 'name' field in tool results
-			const toolResultMsg: ChatCompletionToolMessageParam = {
-				role: "tool",
-				content: sanitizeSurrogates(hasText ? textResult : "(see attached image)"),
-				tool_call_id: normalizeMistralToolId(msg.toolCallId, compat.requiresMistralToolIds),
-			};
-			if (compat.requiresToolResultName && msg.toolName) {
-				(toolResultMsg as any).name = msg.toolName;
+			// Batch consecutive tool results and collect all images
+			const imageBlocks: Array<{ type: "image_url"; image_url: { url: string } }> = [];
+			let j = i;
+
+			for (; j < transformedMessages.length && transformedMessages[j].role === "toolResult"; j++) {
+				const toolMsg = transformedMessages[j] as ToolResultMessage;
+
+				// Extract text and image content
+				const textResult = toolMsg.content
+					.filter((c) => c.type === "text")
+					.map((c) => (c as any).text)
+					.join("\n");
+				const hasImages = toolMsg.content.some((c) => c.type === "image");
+
+				// Always send tool result with text (or placeholder if only images)
+				const hasText = textResult.length > 0;
+				// Some providers (e.g. Mistral) require the 'name' field in tool results
+				const toolResultMsg: ChatCompletionToolMessageParam = {
+					role: "tool",
+					content: sanitizeSurrogates(hasText ? textResult : "(see attached image)"),
+					tool_call_id: normalizeMistralToolId(toolMsg.toolCallId, compat.requiresMistralToolIds),
+				};
+				if (compat.requiresToolResultName && toolMsg.toolName) {
+					(toolResultMsg as any).name = toolMsg.toolName;
+				}
+				params.push(toolResultMsg);
+
+				if (hasImages && model.input.includes("image")) {
+					for (const block of toolMsg.content) {
+						if (block.type === "image") {
+							imageBlocks.push({
+								type: "image_url",
+								image_url: {
+									url: `data:${(block as any).mimeType};base64,${(block as any).data}`,
+								},
+							});
+						}
+					}
+				}
 			}
-			params.push(toolResultMsg);
-
-			// If there are images and model supports them, send a follow-up user message with images
-			if (hasImages && model.input.includes("image")) {
-				const contentBlocks: Array<
-					{ type: "text"; text: string } | { type: "image_url"; image_url: { url: string } }
-				> = [];
-
-				// Add text prefix
-				contentBlocks.push({
-					type: "text",
-					text: "Attached image(s) from tool result:",
-				});
 
-				// Add images
-				for (const block of msg.content) {
-					if (block.type === "image") {
-						contentBlocks.push({
-							type: "image_url",
-							image_url: {
-								url: `data:${(block as any).mimeType};base64,${(block as any).data}`,
-							},
-						});
-					}
+			i = j - 1;
+
+			// After all consecutive tool results, add a single user message with all images
+			if (imageBlocks.length > 0) {
+				if (compat.requiresAssistantAfterToolResult) {
+					params.push({
+						role: "assistant",
+						content: "I have processed the tool results.",
+					});
 				}
 
 				params.push({
 					role: "user",
-					content: contentBlocks,
+					content: [
+						{
+							type: "text",
+							text: "Attached image(s) from tool result:",
+						},
+						...imageBlocks,
+					],
 				});
+				lastRole = "user";
+			} else {
+				lastRole = "toolResult";
 			}
+			continue;
 		}
 
 		lastRole = msg.role;

package/src/providers/openai-responses.ts

@@ -10,8 +10,8 @@ import type {
 	ResponseOutputMessage,
 	ResponseReasoningItem,
 } from "openai/resources/responses/responses";
-import { calculateCost } from "../models";
-import { getEnvApiKey } from "../stream";
+import { calculateCost } from "$ai/models";
+import { getEnvApiKey } from "$ai/stream";
 import type {
 	Api,
 	AssistantMessage,
@@ -24,11 +24,11 @@ import type {
 	ThinkingContent,
 	Tool,
 	ToolCall,
-} from "../types";
-import { AssistantMessageEventStream } from "../utils/event-stream";
-import { parseStreamingJson } from "../utils/json-parse";
-import { formatErrorMessageWithRetryAfter } from "../utils/retry-after";
-import { sanitizeSurrogates } from "../utils/sanitize-unicode";
+} from "$ai/types";
+import { AssistantMessageEventStream } from "$ai/utils/event-stream";
+import { parseStreamingJson } from "$ai/utils/json-parse";
+import { formatErrorMessageWithRetryAfter } from "$ai/utils/retry-after";
+import { sanitizeSurrogates } from "$ai/utils/sanitize-unicode";
 import { transformMessages } from "./transform-messages";
 
 /** Fast deterministic hash to shorten long strings */
@@ -468,6 +468,8 @@ function convertMessages(
 	for (const msg of transformedMessages) {
 		if (msg.role === "user") {
 			if (typeof msg.content === "string") {
+				// Skip empty user messages
+				if (!msg.content || msg.content.trim() === "") continue;
 				messages.push({
 					role: "user",
 					content: [{ type: "input_text", text: sanitizeSurrogates(msg.content) }],
@@ -487,9 +489,16 @@ function convertMessages(
 						} satisfies ResponseInputImage;
 					}
 				});
-				const filteredContent = !model.input.includes("image")
+				// Filter out images if model doesn't support them, and empty text blocks
+				let filteredContent = !model.input.includes("image")
 					? content.filter((c) => c.type !== "input_image")
 					: content;
+				filteredContent = filteredContent.filter((c) => {
+					if (c.type === "input_text") {
+						return c.text.trim().length > 0;
+					}
+					return true; // Keep non-text content (images)
+				});
 				if (filteredContent.length === 0) continue;
 				messages.push({
 					role: "user",
@@ -498,6 +507,15 @@ function convertMessages(
 			}
 		} else if (msg.role === "assistant") {
 			const output: ResponseInput = [];
+			const assistantMsg = msg as AssistantMessage;
+
+			// Check if this message is from a different model (same provider, different model ID).
+			// For such messages, tool call IDs with fc_ prefix need to be stripped to avoid
+			// OpenAI's reasoning/function_call pairing validation errors.
+			const isDifferentModel =
+				assistantMsg.model !== model.id &&
+				assistantMsg.provider === model.provider &&
+				assistantMsg.api === model.api;
 
 			for (const block of msg.content) {
 				// Do not submit thinking blocks if the completion had an error (i.e. abort)
@@ -526,11 +544,19 @@ function convertMessages(
 				} else if (block.type === "toolCall" && msg.stopReason !== "error") {
 					const toolCall = block as ToolCall;
 					const normalized = normalizeResponsesToolCallId(toolCall.id);
+					const callId = normalized.callId;
+					// For different-model messages, set id to undefined to avoid pairing validation.
+					// OpenAI tracks which fc_xxx IDs were paired with rs_xxx reasoning items.
+					// By omitting the id, we avoid triggering that validation (like cross-provider does).
+					let itemId: string | undefined = normalized.itemId;
+					if (isDifferentModel && itemId?.startsWith("fc_")) {
+						itemId = undefined;
+					}
 					knownCallIds.add(normalized.callId);
 					output.push({
 						type: "function_call",
-						id: normalized.itemId,
-						call_id: normalized.callId,
+						id: itemId,
+						call_id: callId,
 						name: toolCall.name,
 						arguments: JSON.stringify(toolCall.arguments),
 					});

package/src/providers/transform-messages.ts

@@ -1,4 +1,4 @@
-import type { Api, AssistantMessage, Message, Model, ToolCall, ToolResultMessage } from "../types";
+import type { Api, AssistantMessage, Message, Model, ToolCall, ToolResultMessage } from "$ai/types";
 
 /**
  * Normalize tool call ID for cross-provider compatibility.

package/src/usage/claude.ts

@@ -0,0 +1,355 @@
+import type {
+	UsageAmount,
+	UsageFetchContext,
+	UsageFetchParams,
+	UsageLimit,
+	UsageProvider,
+	UsageReport,
+	UsageStatus,
+	UsageWindow,
+} from "$ai/usage";
+
+const DEFAULT_ENDPOINT = "https://api.anthropic.com/api/oauth";
+const DEFAULT_CACHE_TTL_MS = 60_000;
+const FIVE_HOURS_MS = 5 * 60 * 60 * 1000;
+const SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
+const MAX_RETRIES = 3;
+const BASE_RETRY_DELAY_MS = 500;
+
+const CLAUDE_HEADERS = {
+	accept: "application/json, text/plain, */*",
+	"accept-encoding": "gzip, compress, deflate, br",
+	"anthropic-beta": "oauth-2025-04-20",
+	"content-type": "application/json",
+	"user-agent": "claude-code/2.0.20",
+	connection: "keep-alive",
+} as const;
+
+function normalizeClaudeBaseUrl(baseUrl?: string): string {
+	if (!baseUrl || !baseUrl.trim()) return DEFAULT_ENDPOINT;
+	const trimmed = baseUrl.trim().replace(/\/+$/, "");
+	const lower = trimmed.toLowerCase();
+	if (lower.endsWith("/api/oauth")) return trimmed;
+	let url: URL;
+	try {
+		url = new URL(trimmed);
+	} catch {
+		return DEFAULT_ENDPOINT;
+	}
+	let path = url.pathname.replace(/\/+$/, "");
+	if (path === "/") path = "";
+	if (path.toLowerCase().endsWith("/v1")) {
+		path = path.slice(0, -3);
+	}
+	if (!path) return `${url.origin}/api/oauth`;
+	return `${url.origin}${path}/api/oauth`;
+}
+
+interface ClaudeUsageBucket {
+	utilization?: number;
+	resets_at?: string;
+}
+
+interface ParsedUsageBucket {
+	utilization?: number;
+	resetsAt?: number;
+}
+
+interface ClaudeUsageResponse {
+	five_hour?: ClaudeUsageBucket | null;
+	seven_day?: ClaudeUsageBucket | null;
+	seven_day_opus?: ClaudeUsageBucket | null;
+	seven_day_sonnet?: ClaudeUsageBucket | null;
+}
+
+type ClaudeUsagePayload = {
+	payload: ClaudeUsageResponse;
+	orgId?: string;
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function toNumber(value: unknown): number | undefined {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "string" && value.trim()) {
+		const parsed = Number(value);
+		return Number.isFinite(parsed) ? parsed : undefined;
+	}
+	return undefined;
+}
+
+function parseIsoTime(value: string | undefined): number | undefined {
+	if (!value) return undefined;
+	const parsed = Date.parse(value);
+	return Number.isFinite(parsed) ? parsed : undefined;
+}
+
+function parseBucket(bucket: unknown): ParsedUsageBucket | undefined {
+	if (!isRecord(bucket)) return undefined;
+	const utilization = toNumber(bucket.utilization);
+	const resetsAt = parseIsoTime(typeof bucket.resets_at === "string" ? bucket.resets_at : undefined);
+	if (utilization === undefined && resetsAt === undefined) {
+		if ("utilization" in bucket || "resets_at" in bucket) {
+			return { utilization: 0, resetsAt: undefined };
+		}
+		return undefined;
+	}
+	return { utilization, resetsAt };
+}
+
+function getPayloadString(payload: Record<string, unknown>, key: string): string | undefined {
+	const value = payload[key];
+	return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function extractUsageIdentity(payload: ClaudeUsageResponse, orgId?: string): { accountId?: string; email?: string } {
+	if (!isRecord(payload)) return { accountId: orgId };
+	const accountId =
+		getPayloadString(payload, "account_id") ??
+		getPayloadString(payload, "accountId") ??
+		getPayloadString(payload, "user_id") ??
+		getPayloadString(payload, "userId") ??
+		getPayloadString(payload, "org_id") ??
+		getPayloadString(payload, "orgId") ??
+		orgId;
+	const email =
+		getPayloadString(payload, "email") ??
+		getPayloadString(payload, "user_email") ??
+		getPayloadString(payload, "userEmail");
+	return { accountId, email };
+}
+
+function hasUsageData(payload: ClaudeUsageResponse): boolean {
+	return Boolean(payload.five_hour || payload.seven_day || payload.seven_day_opus || payload.seven_day_sonnet);
+}
+
+async function fetchUsagePayload(
+	url: string,
+	headers: Record<string, string>,
+	ctx: UsageFetchContext,
+	signal?: AbortSignal,
+): Promise<ClaudeUsagePayload | null> {
+	let lastPayload: ClaudeUsageResponse | null = null;
+	let lastOrgId: string | undefined;
+	for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+		try {
+			const response = await ctx.fetch(url, { headers, signal });
+			if (!response.ok) {
+				ctx.logger?.warn("Claude usage fetch failed", { status: response.status, statusText: response.statusText });
+				return null;
+			}
+			const payload = (await response.json()) as ClaudeUsageResponse;
+			lastPayload = payload;
+			const orgId = response.headers.get("anthropic-organization-id")?.trim() || undefined;
+			lastOrgId = orgId ?? lastOrgId;
+			if (payload && isRecord(payload) && hasUsageData(payload)) {
+				return { payload, orgId };
+			}
+		} catch (error) {
+			ctx.logger?.warn("Claude usage fetch error", { error: String(error) });
+			return null;
+		}
+
+		if (attempt < MAX_RETRIES - 1) {
+			await Bun.sleep(BASE_RETRY_DELAY_MS * 2 ** attempt);
+		}
+	}
+
+	return lastPayload ? { payload: lastPayload, orgId: lastOrgId } : null;
+}
+
+function buildUsageAmount(utilization: number | undefined): UsageAmount | undefined {
+	if (utilization === undefined) return undefined;
+	const clamped = Math.min(Math.max(utilization, 0), 100);
+	const usedFraction = clamped / 100;
+	return {
+		used: clamped,
+		limit: 100,
+		remaining: Math.max(0, 100 - clamped),
+		usedFraction,
+		remainingFraction: Math.max(0, 1 - usedFraction),
+		unit: "percent",
+	};
+}
+
+function buildUsageWindow(
+	id: string,
+	label: string,
+	durationMs: number,
+	resetsAt: number | undefined,
+	now: number,
+): UsageWindow {
+	const resolvedResetAt = resetsAt ?? now + durationMs;
+	const resetInMs = Math.max(0, resolvedResetAt - now);
+	return {
+		id,
+		label,
+		durationMs,
+		resetsAt: resolvedResetAt,
+		resetInMs,
+	};
+}
+
+function buildUsageStatus(usedFraction: number | undefined): UsageStatus | undefined {
+	if (usedFraction === undefined) return undefined;
+	if (usedFraction >= 1) return "exhausted";
+	if (usedFraction >= 0.9) return "warning";
+	return "ok";
+}
+
+function buildUsageLimit(args: {
+	id: string;
+	label: string;
+	windowId: string;
+	windowLabel: string;
+	durationMs: number;
+	bucket: ParsedUsageBucket | undefined;
+	provider: "anthropic";
+	tier?: string;
+	shared?: boolean;
+	now: number;
+}): UsageLimit | null {
+	if (!args.bucket) return null;
+	const amount = buildUsageAmount(args.bucket.utilization);
+	if (!amount) return null;
+	const window = buildUsageWindow(args.windowId, args.windowLabel, args.durationMs, args.bucket.resetsAt, args.now);
+	return {
+		id: args.id,
+		label: args.label,
+		scope: {
+			provider: args.provider,
+			windowId: args.windowId,
+			tier: args.tier,
+			shared: args.shared,
+		},
+		window,
+		amount,
+		status: buildUsageStatus(amount.usedFraction),
+	};
+}
+
+function buildCacheKey(params: UsageFetchParams): string {
+	const credential = params.credential;
+	const account = credential.accountId ?? credential.email ?? "unknown";
+	const token = credential.accessToken ?? credential.refreshToken;
+	const fingerprint = token && typeof token === "string" ? Bun.hash(token).toString(16) : "anonymous";
+	const baseUrl = params.baseUrl ?? DEFAULT_ENDPOINT;
+	return `usage:${params.provider}:${account}:${fingerprint}:${baseUrl}`;
+}
+
+function resolveCacheExpiry(now: number, limits: UsageLimit[]): number {
+	const earliestReset = limits
+		.map((limit) => limit.window?.resetsAt)
+		.filter((value): value is number => typeof value === "number" && Number.isFinite(value))
+		.reduce((min, value) => (min === undefined ? value : Math.min(min, value)), undefined as number | undefined);
+	const exhausted = limits.some((limit) => limit.status === "exhausted");
+	if (earliestReset === undefined) return now + DEFAULT_CACHE_TTL_MS;
+	if (exhausted) return earliestReset;
+	return Math.min(now + DEFAULT_CACHE_TTL_MS, earliestReset);
+}
+
+async function fetchClaudeUsage(params: UsageFetchParams, ctx: UsageFetchContext): Promise<UsageReport | null> {
+	if (params.provider !== "anthropic") return null;
+	const credential = params.credential;
+	if (credential.type !== "oauth" || !credential.accessToken) return null;
+
+	const cacheKey = buildCacheKey(params);
+	const cachedEntry = await ctx.cache.get(cacheKey);
+	const now = ctx.now();
+	if (cachedEntry && cachedEntry.expiresAt > now) {
+		return cachedEntry.value;
+	}
+	const cachedValue = cachedEntry?.value ?? null;
+
+	const baseUrl = normalizeClaudeBaseUrl(params.baseUrl);
+	const url = `${baseUrl}/usage`;
+	const headers: Record<string, string> = {
+		...CLAUDE_HEADERS,
+		authorization: `Bearer ${credential.accessToken}`,
+	};
+
+	const payloadResult = await fetchUsagePayload(url, headers, ctx, params.signal);
+	if (!payloadResult || !isRecord(payloadResult.payload)) return cachedValue;
+	const { payload, orgId } = payloadResult;
+
+	const fiveHour = parseBucket(payload.five_hour);
+	const sevenDay = parseBucket(payload.seven_day);
+	const sevenDayOpus = parseBucket(payload.seven_day_opus);
+	const sevenDaySonnet = parseBucket(payload.seven_day_sonnet);
+
+	const limits = [
+		buildUsageLimit({
+			id: "anthropic:5h",
+			label: "Claude 5 Hour",
+			windowId: "5h",
+			windowLabel: "5 Hour",
+			durationMs: FIVE_HOURS_MS,
+			bucket: fiveHour,
+			provider: "anthropic",
+			shared: true,
+			now,
+		}),
+		buildUsageLimit({
+			id: "anthropic:7d",
+			label: "Claude 7 Day",
+			windowId: "7d",
+			windowLabel: "7 Day",
+			durationMs: SEVEN_DAYS_MS,
+			bucket: sevenDay,
+			provider: "anthropic",
+			shared: true,
+			now,
+		}),
+		buildUsageLimit({
+			id: "anthropic:7d:opus",
+			label: "Claude 7 Day (Opus)",
+			windowId: "7d",
+			windowLabel: "7 Day",
+			durationMs: SEVEN_DAYS_MS,
+			bucket: sevenDayOpus,
+			provider: "anthropic",
+			tier: "opus",
+			now,
+		}),
+		buildUsageLimit({
+			id: "anthropic:7d:sonnet",
+			label: "Claude 7 Day (Sonnet)",
+			windowId: "7d",
+			windowLabel: "7 Day",
+			durationMs: SEVEN_DAYS_MS,
+			bucket: sevenDaySonnet,
+			provider: "anthropic",
+			tier: "sonnet",
+			now,
+		}),
+	].filter((limit): limit is UsageLimit => limit !== null);
+
+	if (limits.length === 0) return cachedValue;
+	const identity = extractUsageIdentity(payload, orgId);
+	const accountId = identity.accountId ?? credential.accountId;
+	const email = identity.email ?? credential.email;
+
+	const report: UsageReport = {
+		provider: params.provider,
+		fetchedAt: now,
+		limits,
+		metadata: {
+			accountId,
+			email,
+			endpoint: url,
+		},
+		raw: payload,
+	};
+
+	const expiresAt = resolveCacheExpiry(now, limits);
+	await ctx.cache.set(cacheKey, { value: report, expiresAt });
+	return report;
+}
+
+export const claudeUsageProvider: UsageProvider = {
+	id: "anthropic",
+	fetchUsage: fetchClaudeUsage,
+	supports: (params) => params.provider === "anthropic" && params.credential.type === "oauth",
+};