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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-ai",
-	"version": "6.9.0",
+	"version": "7.0.0",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -17,7 +17,7 @@
 		"test": "bun test"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-utils": "6.9.0",
+		"@oh-my-pi/pi-utils": "7.0.0",
 		"@anthropic-ai/sdk": "0.71.2",
 		"@aws-sdk/client-bedrock-runtime": "^3.968.0",
 		"@bufbuild/protobuf": "^2.10.2",

package/src/index.ts

@@ -5,11 +5,18 @@ export * from "./providers/anthropic";
 export * from "./providers/cursor";
 export * from "./providers/google";
 export * from "./providers/google-gemini-cli";
+export * from "./providers/google-gemini-cli-usage";
 export * from "./providers/google-vertex";
 export * from "./providers/openai-completions";
 export * from "./providers/openai-responses";
 export * from "./stream";
 export * from "./types";
+export * from "./usage";
+export * from "./usage/claude";
+export * from "./usage/github-copilot";
+export * from "./usage/google-antigravity";
+export * from "./usage/openai-codex";
+export * from "./usage/zai";
 export * from "./utils/event-stream";
 export * from "./utils/oauth/index";
 export * from "./utils/overflow";

package/src/providers/amazon-bedrock.ts

@@ -67,6 +67,9 @@ export const streamBedrock: StreamFunction<"bedrock-converse-stream"> = (
 	const stream = new AssistantMessageEventStream();
 
 	(async () => {
+		const startTime = Date.now();
+		let firstTokenTime: number | undefined;
+
 		const output: AssistantMessage = {
 			role: "assistant",
 			content: [],
@@ -113,8 +116,10 @@ export const streamBedrock: StreamFunction<"bedrock-converse-stream"> = (
 					}
 					stream.push({ type: "start", partial: output });
 				} else if (item.contentBlockStart) {
+					if (!firstTokenTime) firstTokenTime = Date.now();
 					handleContentBlockStart(item.contentBlockStart, blocks, output, stream);
 				} else if (item.contentBlockDelta) {
+					if (!firstTokenTime) firstTokenTime = Date.now();
 					handleContentBlockDelta(item.contentBlockDelta, blocks, output, stream);
 				} else if (item.contentBlockStop) {
 					handleContentBlockStop(item.contentBlockStop, blocks, output, stream);
@@ -143,6 +148,8 @@ export const streamBedrock: StreamFunction<"bedrock-converse-stream"> = (
 				throw new Error("An unknown error occurred");
 			}
 
+			output.duration = Date.now() - startTime;
+			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
 			stream.push({ type: "done", reason: output.stopReason, message: output });
 			stream.end();
 		} catch (error) {
@@ -152,6 +159,8 @@ export const streamBedrock: StreamFunction<"bedrock-converse-stream"> = (
 			}
 			output.stopReason = options.signal?.aborted ? "aborted" : "error";
 			output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
+			output.duration = Date.now() - startTime;
+			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
 			stream.push({ type: "error", reason: output.stopReason, error: output });
 			stream.end();
 		}
@@ -333,22 +342,39 @@ function convertMessages(context: Context, model: Model<"bedrock-converse-stream
 
 		switch (m.role) {
 			case "user":
-				result.push({
-					role: ConversationRole.USER,
-					content:
-						typeof m.content === "string"
-							? [{ text: sanitizeSurrogates(m.content) }]
-							: m.content.map((c) => {
-									switch (c.type) {
-										case "text":
-											return { text: sanitizeSurrogates(c.text) };
-										case "image":
-											return { image: createImageBlock(c.mimeType, c.data) };
-										default:
-											throw new Error("Unknown user content type");
-									}
-								}),
-				});
+				if (typeof m.content === "string") {
+					// Skip empty user messages
+					if (!m.content || m.content.trim() === "") continue;
+					result.push({
+						role: ConversationRole.USER,
+						content: [{ text: sanitizeSurrogates(m.content) }],
+					});
+				} else {
+					const contentBlocks = m.content
+						.map((c) => {
+							switch (c.type) {
+								case "text":
+									return { text: sanitizeSurrogates(c.text) };
+								case "image":
+									return { image: createImageBlock(c.mimeType, c.data) };
+								default:
+									throw new Error("Unknown user content type");
+							}
+						})
+						.filter((block) => {
+							// Filter out empty text blocks
+							if ("text" in block && block.text) {
+								return block.text.trim().length > 0;
+							}
+							return true; // Keep non-text blocks (images)
+						});
+					// Skip message if all blocks filtered out
+					if (contentBlocks.length === 0) continue;
+					result.push({
+						role: ConversationRole.USER,
+						content: contentBlocks,
+					});
+				}
 				break;
 			case "assistant": {
 				// Skip assistant messages with empty content (e.g., from aborted requests)

package/src/providers/anthropic.ts

@@ -140,6 +140,9 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 	const stream = new AssistantMessageEventStream();
 
 	(async () => {
+		const startTime = Date.now();
+		let firstTokenTime: number | undefined;
+
 		const output: AssistantMessage = {
 			role: "assistant",
 			content: [],
@@ -183,6 +186,7 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 						output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
 					calculateCost(model, output.usage);
 				} else if (event.type === "content_block_start") {
+					if (!firstTokenTime) firstTokenTime = Date.now();
 					if (event.content_block.type === "text") {
 						const block: Block = {
 							type: "text",
@@ -321,12 +325,16 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 				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();
 		}

package/src/providers/cursor.ts

@@ -294,6 +294,9 @@ export const streamCursor: StreamFunction<"cursor-agent"> = (
 	const stream = new AssistantMessageEventStream();
 
 	(async () => {
+		const startTime = Date.now();
+		let firstTokenTime: number | undefined;
+
 		const output: AssistantMessage = {
 			role: "assistant",
 			content: [],
@@ -369,6 +372,9 @@ export const streamCursor: StreamFunction<"cursor-agent"> = (
 				get currentToolCall() {
 					return currentToolCall;
 				},
+				get firstTokenTime() {
+					return firstTokenTime;
+				},
 				setTextBlock: (b) => {
 					currentTextBlock = b;
 				},
@@ -378,6 +384,9 @@ export const streamCursor: StreamFunction<"cursor-agent"> = (
 				setToolCall: (t) => {
 					currentToolCall = t;
 				},
+				setFirstTokenTime: () => {
+					if (!firstTokenTime) firstTokenTime = Date.now();
+				},
 			};
 
 			const onConversationCheckpoint = (checkpoint: ConversationStateStructure) => {
@@ -502,6 +511,8 @@ export const streamCursor: StreamFunction<"cursor-agent"> = (
 
 			calculateCost(model, output.usage);
 
+			output.duration = Date.now() - startTime;
+			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
 			stream.push({
 				type: "done",
 				reason: output.stopReason as "stop" | "length" | "toolUse",
@@ -511,6 +522,8 @@ export const streamCursor: StreamFunction<"cursor-agent"> = (
 		} catch (error) {
 			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();
 		} finally {
@@ -532,9 +545,11 @@ interface BlockState {
 	currentTextBlock: (TextContent & { index: number }) | null;
 	currentThinkingBlock: (ThinkingContent & { index: number }) | null;
 	currentToolCall: ToolCallState | null;
+	firstTokenTime: number | undefined;
 	setTextBlock: (b: (TextContent & { index: number }) | null) => void;
 	setThinkingBlock: (b: (ThinkingContent & { index: number }) | null) => void;
 	setToolCall: (t: ToolCallState | null) => void;
+	setFirstTokenTime: () => void;
 }
 
 interface UsageState {
@@ -1645,6 +1660,7 @@ function processInteractionUpdate(
 	log("interactionUpdate", updateCase, update.message?.value);
 
 	if (updateCase === "textDelta") {
+		state.setFirstTokenTime();
 		const delta = update.message.value.text || "";
 		if (!state.currentTextBlock) {
 			const block: TextContent & { index: number } = {
@@ -1660,6 +1676,7 @@ function processInteractionUpdate(
 		const idx = output.content.indexOf(state.currentTextBlock!);
 		stream.push({ type: "text_delta", contentIndex: idx, delta, partial: output });
 	} else if (updateCase === "thinkingDelta") {
+		state.setFirstTokenTime();
 		const delta = update.message.value.text || "";
 		if (!state.currentThinkingBlock) {
 			const block: ThinkingContent & { index: number } = {
@@ -1821,11 +1838,12 @@ function buildMcpToolDefinitions(tools: Tool[] | undefined): McpToolDefinition[]
 function extractUserMessageText(msg: Message): string {
 	if (msg.role !== "user") return "";
 	const content = msg.content;
-	if (typeof content === "string") return content;
-	return content
+	if (typeof content === "string") return content.trim();
+	const text = content
 		.filter((c): c is TextContent => c.type === "text")
 		.map((c) => c.text)
 		.join("\n");
+	return text.trim();
 }
 
 /**
@@ -1874,7 +1892,7 @@ function buildConversationTurns(messages: Message[]): Uint8Array[] {
 
 		// Create and serialize user message
 		const userText = extractUserMessageText(msg);
-		if (!userText) {
+		if (!userText || userText.length === 0) {
 			i++;
 			continue;
 		}
@@ -1965,10 +1983,15 @@ function buildGrpcRequest(
 	const userText =
 		lastMessage?.role === "user"
 			? typeof lastMessage.content === "string"
-				? lastMessage.content
+				? lastMessage.content.trim()
 				: extractText(lastMessage.content)
 			: "";
 
+	// Validate that we have non-empty user text for the action
+	if (!userText || userText.trim().length === 0) {
+		throw new Error("Cannot send empty user message to Cursor API");
+	}
+
 	const userMessage = create(UserMessageSchema, {
 		text: userText,
 		messageId: crypto.randomUUID(),

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

@@ -0,0 +1,271 @@
+import type {
+	UsageAmount,
+	UsageFetchContext,
+	UsageFetchParams,
+	UsageLimit,
+	UsageProvider,
+	UsageReport,
+	UsageWindow,
+} from "../usage";
+import { refreshGoogleCloudToken } from "../utils/oauth/google-gemini-cli";
+
+const DEFAULT_ENDPOINT = "https://cloudcode-pa.googleapis.com";
+const CACHE_TTL_MS = 60_000;
+
+const GEMINI_CLI_HEADERS = {
+	"User-Agent": "google-cloud-sdk vscode_cloudshelleditor/0.1",
+	"X-Goog-Api-Client": "gl-node/22.17.0",
+	"Client-Metadata": JSON.stringify({
+		ideType: "IDE_UNSPECIFIED",
+		platform: "PLATFORM_UNSPECIFIED",
+		pluginType: "GEMINI",
+	}),
+};
+
+const GEMINI_TIER_MAP: Array<{ tier: string; models: string[] }> = [
+	{
+		tier: "3-Flash",
+		models: ["gemini-3-flash-preview", "gemini-3-flash"],
+	},
+	{
+		tier: "Flash",
+		models: ["gemini-2.5-flash", "gemini-2.5-flash-lite", "gemini-2.0-flash", "gemini-1.5-flash"],
+	},
+	{
+		tier: "Pro",
+		models: ["gemini-2.5-pro", "gemini-3-pro-preview", "gemini-3-pro", "gemini-1.5-pro"],
+	},
+];
+
+interface LoadCodeAssistResponse {
+	cloudaicompanionProject?: string | { id?: string };
+	currentTier?: { id?: string; name?: string };
+}
+
+interface RetrieveUserQuotaResponse {
+	buckets?: Array<{
+		modelId?: string;
+		remainingFraction?: number;
+		resetTime?: string;
+	}>;
+}
+
+function getProjectId(payload: LoadCodeAssistResponse | undefined): string | undefined {
+	if (!payload) return undefined;
+	if (typeof payload.cloudaicompanionProject === "string") {
+		return payload.cloudaicompanionProject;
+	}
+	if (payload.cloudaicompanionProject && typeof payload.cloudaicompanionProject === "object") {
+		return payload.cloudaicompanionProject.id;
+	}
+	return undefined;
+}
+
+function getModelTier(modelId: string): string | undefined {
+	for (const entry of GEMINI_TIER_MAP) {
+		if (entry.models.includes(modelId)) {
+			return entry.tier;
+		}
+	}
+	const normalized = modelId.toLowerCase();
+	if (normalized.includes("flash")) return "Flash";
+	if (normalized.includes("pro")) return "Pro";
+	return undefined;
+}
+
+function parseWindow(resetTime: string | undefined, now: number): UsageWindow {
+	if (!resetTime) {
+		return {
+			id: "quota",
+			label: "Quota window",
+		};
+	}
+	const resetsAt = Date.parse(resetTime);
+	if (Number.isNaN(resetsAt)) {
+		return {
+			id: "quota",
+			label: "Quota window",
+		};
+	}
+	return {
+		id: `reset-${resetsAt}`,
+		label: "Quota window",
+		resetsAt,
+		resetInMs: Math.max(0, resetsAt - now),
+	};
+}
+
+function buildAmount(remainingFraction: number | undefined): UsageAmount {
+	if (remainingFraction === undefined || !Number.isFinite(remainingFraction)) {
+		return { unit: "percent" };
+	}
+	const remaining = Math.min(Math.max(remainingFraction, 0), 1);
+	const used = Math.min(Math.max(1 - remaining, 0), 1);
+	return {
+		unit: "percent",
+		used: Math.round(used * 1000) / 10,
+		remaining: Math.round(remaining * 1000) / 10,
+		limit: 100,
+		usedFraction: used,
+		remainingFraction: remaining,
+	};
+}
+
+async function resolveAccessToken(params: UsageFetchParams, ctx: UsageFetchContext): Promise<string | undefined> {
+	const { credential } = params;
+	if (credential.type !== "oauth") return undefined;
+	const now = ctx.now();
+	if (credential.accessToken && (!credential.expiresAt || credential.expiresAt > now + 60_000)) {
+		return credential.accessToken;
+	}
+	if (!credential.refreshToken || !credential.projectId) return credential.accessToken;
+	try {
+		const refreshed = await refreshGoogleCloudToken(credential.refreshToken, credential.projectId);
+		return refreshed.access;
+	} catch (error) {
+		ctx.logger?.warn("Gemini CLI token refresh failed", { error: String(error) });
+		return credential.accessToken;
+	}
+}
+
+async function loadCodeAssist(
+	params: UsageFetchParams,
+	ctx: UsageFetchContext,
+	accessToken: string,
+	baseUrl: string,
+	projectId?: string,
+): Promise<LoadCodeAssistResponse | undefined> {
+	const response = await ctx.fetch(`${baseUrl}/v1internal:loadCodeAssist`, {
+		method: "POST",
+		headers: {
+			Authorization: `Bearer ${accessToken}`,
+			"Content-Type": "application/json",
+			...GEMINI_CLI_HEADERS,
+		},
+		body: JSON.stringify({
+			...(projectId ? { cloudaicompanionProject: projectId } : {}),
+			metadata: {
+				ideType: "IDE_UNSPECIFIED",
+				platform: "PLATFORM_UNSPECIFIED",
+				pluginType: "GEMINI",
+			},
+		}),
+		signal: params.signal,
+	});
+
+	if (!response.ok) {
+		const errorText = await response.text();
+		ctx.logger?.warn("Gemini CLI loadCodeAssist failed", {
+			status: response.status,
+			error: errorText,
+		});
+		return undefined;
+	}
+
+	return (await response.json()) as LoadCodeAssistResponse;
+}
+
+async function fetchQuota(
+	params: UsageFetchParams,
+	ctx: UsageFetchContext,
+	accessToken: string,
+	baseUrl: string,
+	projectId?: string,
+): Promise<RetrieveUserQuotaResponse | undefined> {
+	const response = await ctx.fetch(`${baseUrl}/v1internal:retrieveUserQuota`, {
+		method: "POST",
+		headers: {
+			Authorization: `Bearer ${accessToken}`,
+			"Content-Type": "application/json",
+			...GEMINI_CLI_HEADERS,
+		},
+		body: JSON.stringify(projectId ? { project: projectId } : {}),
+		signal: params.signal,
+	});
+
+	if (!response.ok) {
+		const errorText = await response.text();
+		ctx.logger?.warn("Gemini CLI retrieveUserQuota failed", {
+			status: response.status,
+			error: errorText,
+		});
+		return undefined;
+	}
+
+	return (await response.json()) as RetrieveUserQuotaResponse;
+}
+
+export const googleGeminiCliUsageProvider: UsageProvider = {
+	id: "google-gemini-cli",
+	supports: ({ credential }) => credential.type === "oauth" && !!credential.accessToken,
+	async fetchUsage(params, ctx) {
+		const { credential } = params;
+		if (credential.type !== "oauth") {
+			return null;
+		}
+		const accessToken = await resolveAccessToken(params, ctx);
+		if (!accessToken) {
+			return null;
+		}
+
+		const now = ctx.now();
+		const baseUrl = (params.baseUrl?.trim() || DEFAULT_ENDPOINT).replace(/\/$/, "");
+		const cacheKey = `usage:${params.provider}:${credential.accountId ?? credential.email ?? "default"}:${baseUrl}:${
+			credential.projectId ?? "default"
+		}`;
+		const cached = await ctx.cache.get(cacheKey);
+		if (cached && cached.expiresAt > now) {
+			return cached.value;
+		}
+
+		const loadResponse = await loadCodeAssist(params, ctx, accessToken, baseUrl, credential.projectId);
+		const projectId = credential.projectId ?? getProjectId(loadResponse);
+		const quotaResponse = await fetchQuota(params, ctx, accessToken, baseUrl, projectId);
+		if (!quotaResponse) {
+			const entry = { value: null, expiresAt: now + CACHE_TTL_MS };
+			await ctx.cache.set(cacheKey, entry);
+			return null;
+		}
+
+		const limits: UsageLimit[] = [];
+		const buckets = quotaResponse.buckets ?? [];
+
+		buckets.forEach((bucket, index) => {
+			const modelId = bucket.modelId;
+			const window = parseWindow(bucket.resetTime, now);
+			const amount = buildAmount(bucket.remainingFraction);
+			const tier = modelId ? getModelTier(modelId) : undefined;
+			const label = modelId ? `Gemini ${modelId}` : "Gemini quota";
+			const id = `${modelId ?? "unknown"}:${window?.id ?? index}`;
+
+			limits.push({
+				id,
+				label,
+				scope: {
+					provider: params.provider,
+					accountId: credential.accountId,
+					projectId,
+					modelId,
+					tier,
+					windowId: window?.id,
+				},
+				window,
+				amount,
+			});
+		});
+
+		const report: UsageReport = {
+			provider: params.provider,
+			fetchedAt: now,
+			limits,
+			metadata: {
+				currentTierId: loadResponse?.currentTier?.id,
+				currentTierName: loadResponse?.currentTier?.name,
+			},
+			raw: quotaResponse,
+		};
+
+		await ctx.cache.set(cacheKey, { value: report, expiresAt: now + CACHE_TTL_MS });
+		return report;
+	},
+};

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

@@ -365,6 +365,9 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 	const stream = new AssistantMessageEventStream();
 
 	(async () => {
+		const startTime = Date.now();
+		let firstTokenTime: number | undefined;
+
 		const output: AssistantMessage = {
 			role: "assistant",
 			content: [],
@@ -489,6 +492,7 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 			let started = false;
 			const ensureStarted = () => {
 				if (!started) {
+					if (!firstTokenTime) firstTokenTime = Date.now();
 					stream.push({ type: "start", partial: output });
 					started = true;
 				}
@@ -802,6 +806,8 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 				throw new Error("An unknown error occurred");
 			}
 
+			output.duration = Date.now() - startTime;
+			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
 			stream.push({ type: "done", reason: output.stopReason, message: output });
 			stream.end();
 		} catch (error) {
@@ -812,6 +818,8 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 			}
 			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
 			output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
+			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/google-shared.ts

@@ -79,6 +79,8 @@ export function convertMessages<T extends GoogleApiType>(model: Model<T>, 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;
 				contents.push({
 					role: "user",
 					parts: [{ text: sanitizeSurrogates(msg.content) }],
@@ -96,7 +98,14 @@ export function convertMessages<T extends GoogleApiType>(model: Model<T>, contex
 						};
 					}
 				});
-				const filteredParts = !model.input.includes("image") ? parts.filter((p) => p.text !== undefined) : parts;
+				// Filter out images if model doesn't support them, and empty text blocks
+				let filteredParts = !model.input.includes("image") ? parts.filter((p) => p.text !== undefined) : parts;
+				filteredParts = filteredParts.filter((p) => {
+					if (p.text !== undefined) {
+						return p.text.trim().length > 0;
+					}
+					return true; // Keep non-text parts (images)
+				});
 				if (filteredParts.length === 0) continue;
 				contents.push({
 					role: "user",

package/src/providers/google-vertex.ts

@@ -62,6 +62,9 @@ export const streamGoogleVertex: StreamFunction<"google-vertex"> = (
 	const stream = new AssistantMessageEventStream();
 
 	(async () => {
+		const startTime = Date.now();
+		let firstTokenTime: number | undefined;
+
 		const output: AssistantMessage = {
 			role: "assistant",
 			content: [],
@@ -97,6 +100,7 @@ export const streamGoogleVertex: StreamFunction<"google-vertex"> = (
 				if (candidate?.content?.parts) {
 					for (const part of candidate.content.parts) {
 						if (part.text !== undefined) {
+							if (!firstTokenTime) firstTokenTime = Date.now();
 							const isThinking = isThinkingPart(part);
 							if (
 								!currentBlock ||
@@ -258,6 +262,8 @@ export const streamGoogleVertex: StreamFunction<"google-vertex"> = (
 				throw new Error("An unknown error occurred");
 			}
 
+			output.duration = Date.now() - startTime;
+			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
 			stream.push({ type: "done", reason: output.stopReason, message: output });
 			stream.end();
 		} catch (error) {
@@ -269,6 +275,8 @@ export const streamGoogleVertex: StreamFunction<"google-vertex"> = (
 			}
 			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();
 		}

package/src/providers/google.ts

@@ -53,6 +53,9 @@ export const streamGoogle: StreamFunction<"google-generative-ai"> = (
 	const stream = new AssistantMessageEventStream();
 
 	(async () => {
+		const startTime = Date.now();
+		let firstTokenTime: number | undefined;
+
 		const output: AssistantMessage = {
 			role: "assistant",
 			content: [],
@@ -88,6 +91,7 @@ export const streamGoogle: StreamFunction<"google-generative-ai"> = (
 					for (const part of candidate.content.parts) {
 						if (part.text !== undefined) {
 							const isThinking = isThinkingPart(part);
+							if (!firstTokenTime) firstTokenTime = Date.now();
 							if (
 								!currentBlock ||
 								(isThinking && currentBlock.type !== "thinking") ||
@@ -245,6 +249,8 @@ export const streamGoogle: StreamFunction<"google-generative-ai"> = (
 				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) {
@@ -256,6 +262,8 @@ export const streamGoogle: StreamFunction<"google-generative-ai"> = (
 			}
 			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();
 		}