@oh-my-pi/pi-ai 6.9.0 → 7.0.0

package/src/providers/openai-codex/request-transformer.ts

@@ -50,6 +50,10 @@ function clampReasoningEffort(model: string, effort: ReasoningConfig["effort"]):
 		return "high";
 	}
 
+	if ((modelId === "gpt-5.2" || modelId === "gpt-5.2-codex") && effort === "minimal") {
+		return "low";
+	}
+
 	// gpt-5.1-codex-mini only supports medium/high.
 	if (modelId === "gpt-5.1-codex-mini") {
 		return effort === "high" || effort === "xhigh" ? "high" : "medium";

package/src/providers/openai-codex-responses.ts

@@ -105,6 +105,9 @@ export const streamOpenAICodexResponses: StreamFunction<"openai-codex-responses"
 	const stream = new AssistantMessageEventStream();
 
 	(async () => {
+		const startTime = Date.now();
+		let firstTokenTime: number | undefined;
+
 		const output: AssistantMessage = {
 			role: "assistant",
 			content: [],
@@ -225,6 +228,7 @@ export const streamOpenAICodexResponses: StreamFunction<"openai-codex-responses"
 				if (!eventType) continue;
 
 				if (eventType === "response.output_item.added") {
+					if (!firstTokenTime) firstTokenTime = Date.now();
 					const item = rawEvent.item as ResponseReasoningItem | ResponseOutputMessage | ResponseFunctionToolCall;
 					if (item.type === "reasoning") {
 						currentItem = item;
@@ -412,12 +416,16 @@ export const streamOpenAICodexResponses: StreamFunction<"openai-codex-responses"
 				throw new Error("Codex response failed");
 			}
 
+			output.duration = Date.now() - startTime;
+			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
 			stream.push({ type: "done", reason: output.stopReason, message: output });
 			stream.end();
 		} catch (error) {
 			for (const block of output.content) delete (block as { index?: number }).index;
 			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
 			output.errorMessage = formatErrorMessageWithRetryAfter(error);
+			output.duration = Date.now() - startTime;
+			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
 			stream.push({ type: "error", reason: output.stopReason, error: output });
 			stream.end();
 		}
@@ -563,6 +571,8 @@ function convertMessages(model: Model<"openai-codex-responses">, context: Contex
 	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) }],
@@ -581,9 +591,16 @@ function convertMessages(model: Model<"openai-codex-responses">, context: Contex
 						image_url: `data:${item.mimeType};base64,${item.data}`,
 					} 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",

package/src/providers/openai-completions.ts

@@ -81,6 +81,9 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 	const stream = new AssistantMessageEventStream();
 
 	(async () => {
+		const startTime = Date.now();
+		let firstTokenTime: number | undefined;
+
 		const output: AssistantMessage = {
 			role: "assistant",
 			content: [],
@@ -178,6 +181,7 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 						choice.delta.content !== undefined &&
 						choice.delta.content.length > 0
 					) {
+						if (!firstTokenTime) firstTokenTime = Date.now();
 						if (!currentBlock || currentBlock.type !== "text") {
 							finishCurrentBlock(currentBlock);
 							currentBlock = { type: "text", text: "" };
@@ -303,6 +307,8 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 				throw new Error("An unkown error ocurred");
 			}
 
+			output.duration = Date.now() - startTime;
+			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
 			stream.push({ type: "done", reason: output.stopReason, message: output });
 			stream.end();
 		} catch (error) {
@@ -312,6 +318,8 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 			// Some providers via OpenRouter include extra details here.
 			const rawMetadata = (error as { error?: { metadata?: { raw?: string } } })?.error?.metadata?.raw;
 			if (rawMetadata) output.errorMessage += `\n${rawMetadata}`;
+			output.duration = Date.now() - startTime;
+			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
 			stream.push({ type: "error", reason: output.stopReason, error: output });
 			stream.end();
 		}

package/src/providers/openai-responses.ts

@@ -69,6 +69,9 @@ export const streamOpenAIResponses: StreamFunction<"openai-responses"> = (
 
 	// Start async processing
 	(async () => {
+		const startTime = Date.now();
+		let firstTokenTime: number | undefined;
+
 		const output: AssistantMessage = {
 			role: "assistant",
 			content: [],
@@ -107,6 +110,7 @@ export const streamOpenAIResponses: StreamFunction<"openai-responses"> = (
 			for await (const event of openaiStream) {
 				// Handle output item start
 				if (event.type === "response.output_item.added") {
+					if (!firstTokenTime) firstTokenTime = Date.now();
 					const item = event.item;
 					if (item.type === "reasoning") {
 						currentItem = item;
@@ -309,12 +313,16 @@ export const streamOpenAIResponses: StreamFunction<"openai-responses"> = (
 				throw new Error("An unkown error ocurred");
 			}
 
+			output.duration = Date.now() - startTime;
+			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
 			stream.push({ type: "done", reason: output.stopReason, message: output });
 			stream.end();
 		} catch (error) {
 			for (const block of output.content) delete (block as any).index;
 			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
 			output.errorMessage = formatErrorMessageWithRetryAfter(error);
+			output.duration = Date.now() - startTime;
+			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
 			stream.push({ type: "error", reason: output.stopReason, error: output });
 			stream.end();
 		}
@@ -460,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) }],
@@ -479,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",

package/src/types.ts

@@ -193,6 +193,8 @@ export interface AssistantMessage {
 	stopReason: StopReason;
 	errorMessage?: string;
 	timestamp: number; // Unix timestamp in milliseconds
+	duration?: number; // Request duration in milliseconds
+	ttft?: number; // Time to first token in milliseconds
 }
 
 export interface ToolResultMessage<TDetails = any, TInput = unknown> {

package/src/usage/claude.ts

@@ -0,0 +1,355 @@
+import type {
+	UsageAmount,
+	UsageFetchContext,
+	UsageFetchParams,
+	UsageLimit,
+	UsageProvider,
+	UsageReport,
+	UsageStatus,
+	UsageWindow,
+} from "../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",
+};