@oh-my-pi/pi-ai 16.2.5 → 16.2.7

package/src/auth-storage.ts

@@ -1736,8 +1736,8 @@ export class AuthStorage {
 	/**
 	 * Classify where a provider's auth comes from, following the same precedence
 	 * as {@link AuthStorage.getApiKey}: runtime override → config override →
-	 * stored credential (api_key before oauth, matching getApiKey) → env var →
-	 * fallback resolver. Returns undefined when no auth is configured.
+	 * stored OAuth → env var → stored api_key → fallback resolver. Returns
+	 * undefined when no auth is configured.
 	 *
 	 * Compact, structured counterpart to {@link describeCredentialSource}.
 	 */
@@ -1745,10 +1745,9 @@ export class AuthStorage {
 		if (this.#runtimeOverrides.has(provider)) return { kind: "runtime" };
 		if (this.#configOverrides.has(provider)) return { kind: "config" };
 		const stored = this.#getCredentialsForProvider(provider);
-		if (stored.length > 0) {
-			return { kind: stored.some(credential => credential.type === "api_key") ? "api_key" : "oauth" };
-		}
+		if (stored.some(credential => credential.type === "oauth")) return { kind: "oauth" };
 		if (getEnvApiKey(provider)) return { kind: "env", envVar: getEnvApiKeyName(provider) };
+		if (stored.some(credential => credential.type === "api_key")) return { kind: "api_key" };
 		if (this.#fallbackResolver?.(provider)) return { kind: "fallback" };
 		return undefined;
 	}
@@ -3760,12 +3759,8 @@ export class AuthStorage {
 			return configKey;
 		}
 
-		const apiKeySelection = this.#selectCredentialByType(provider, "api_key");
-		if (apiKeySelection) {
-			return this.#configValueResolver(apiKeySelection.credential.key);
-		}
-
-		// Return current OAuth access token only if it is not already expired.
+		// Precedence: a deliberate OAuth login wins, then an explicit env var, then a stored
+		// static api_key (which may be a stale broker-migrated copy) as a last resort.
 		const oauthSelection = this.#selectCredentialByType(provider, "oauth");
 		if (oauthSelection) {
 			const expiresAt = oauthSelection.credential.expires;
@@ -3784,17 +3779,22 @@ export class AuthStorage {
 		const envKey = getEnvApiKey(provider);
 		if (envKey) return envKey;
 
+		const apiKeySelection = this.#selectCredentialByType(provider, "api_key");
+		if (apiKeySelection) {
+			return this.#configValueResolver(apiKeySelection.credential.key);
+		}
+
 		return this.#fallbackResolver?.(provider) ?? undefined;
 	}
 
 	/**
 	 * Get API key for a provider.
-	 * Priority:
+	 * Priority (first match wins):
 	 * 1. Runtime override (CLI --api-key)
 	 * 2. Config override (models.yml `providers.<name>.apiKey`)
-	 * 3. API key from storage
-	 * 4. OAuth token from storage (auto-refreshed)
-	 * 5. Environment variable
+	 * 3. OAuth token from storage (auto-refreshed)
+	 * 4. Environment variable
+	 * 5. Stored API key (e.g. a broker-migrated copy) — last resort, so an explicit env var wins
 	 * 6. Fallback resolver (models.yml custom providers, last-resort)
 	 */
 	async getApiKey(provider: string, sessionId?: string, options?: AuthApiKeyOptions): Promise<string | undefined> {
@@ -3814,25 +3814,27 @@ export class AuthStorage {
 			return configKey;
 		}
 
-		const apiKeySelection = this.#selectCredentialByType(provider, "api_key", sessionId);
-		if (apiKeySelection) {
-			this.#recordSessionCredential(provider, sessionId, "api_key", apiKeySelection.index);
-			return this.#configValueResolver(apiKeySelection.credential.key);
-		}
-
+		// Precedence: a deliberate OAuth login wins, then an explicit env var, then a stored
+		// static api_key (which may be a stale broker-migrated copy) as a last resort.
 		const oauthResolved = await this.#resolveOAuthSelection(provider, sessionId, options);
 		if (oauthResolved) {
 			return oauthResolved.apiKey;
 		}
 
-		// Fall back to environment variable or custom resolver. If we reach here after
-		// an OAuth miss, the session sticky (if any) is stale — the request will
-		// authenticate via env/fallback, not OAuth, so clear the sticky now so that
-		// getOAuthAccountId() correctly suppresses account_uuid for this session.
+		// Past OAuth: the session sticky (if any) is stale — the request authenticates via
+		// env/api_key/fallback, not OAuth, so clear it now so getOAuthAccountId() correctly
+		// suppresses account_uuid for this session.
 		if (sessionId) this.#sessionLastCredential.get(provider)?.delete(sessionId);
+
 		const envKey = getEnvApiKey(provider);
 		if (envKey) return envKey;
 
+		const apiKeySelection = this.#selectCredentialByType(provider, "api_key", sessionId);
+		if (apiKeySelection) {
+			this.#recordSessionCredential(provider, sessionId, "api_key", apiKeySelection.index);
+			return this.#configValueResolver(apiKeySelection.credential.key);
+		}
+
 		// Fall back to custom resolver (e.g., models.json custom providers)
 		return this.#fallbackResolver?.(provider) ?? undefined;
 	}
@@ -4486,12 +4488,13 @@ export class AuthStorage {
 	/**
 	 * Describe where the active credential for a provider came from.
 	 *
-	 * Surfaces four layers, highest precedence first:
+	 * Mirrors {@link AuthStorage.getApiKey} precedence, highest first:
 	 *   1. Runtime override (`--api-key`).
 	 *   2. Config override (`models.yml` `providers.<name>.apiKey`).
-	 *   3. Stored credential (the one this session is currently sticky to, or the
-	 *      one round-robin would pick next when no session id is supplied).
-	 *   4. Env var / fallback resolver — when no stored credential exists.
+	 *   3. Stored OAuth credential.
+	 *   4. Env var — overrides a stored static api_key (e.g. a stale broker copy).
+	 *   5. Stored api_key credential.
+	 *   6. Fallback resolver.
 	 *
 	 * The string is purely informational; consumers must not parse it.
 	 */
@@ -4505,30 +4508,31 @@ export class AuthStorage {
 
 		const baseLabel = this.#sourceLabel ?? "local store";
 		const stored = this.#getStoredCredentials(provider);
-		if (stored.length === 0) {
-			if (getEnvApiKey(provider)) return `env ${baseLabel ? `(fallback over ${baseLabel})` : ""}`.trim();
-			if (this.#fallbackResolver?.(provider) !== undefined) return `fallback resolver`;
-			return undefined;
-		}
-
 		const session = sessionId ? this.#sessionLastCredential.get(provider)?.get(sessionId) : undefined;
-		// Same selection logic as #selectCredentialByType for "no session" lookups: prefer
-		// the type with stored credentials, lean OAuth before api_key. We don't run the
-		// full round-robin here because describing the source shouldn't advance the index.
-		const preferredType: AuthCredential["type"] =
-			session?.type ?? (stored.some(entry => entry.credential.type === "oauth") ? "oauth" : "api_key");
-		const typed = stored
-			.map((entry, index) => ({ entry, index }))
-			.filter(({ entry }) => entry.credential.type === preferredType);
-		if (typed.length === 0) return baseLabel;
-		const index = session?.index ?? typed[0].index;
-		const chosen = stored[index] ?? typed[0].entry;
-		const credential = chosen.credential;
-		const identity =
-			credential.type === "oauth"
-				? (credential.email ?? credential.accountId ?? credential.projectId ?? `cred ${chosen.id}`)
-				: `cred ${chosen.id}`;
-		return `${baseLabel} · ${preferredType} #${chosen.id} (${identity})`;
+		// Describe the stored credential of a given type, honoring the session sticky index.
+		const describeStored = (type: AuthCredential["type"]): string | undefined => {
+			const typed = stored
+				.map((entry, index) => ({ entry, index }))
+				.filter(({ entry }) => entry.credential.type === type);
+			if (typed.length === 0) return undefined;
+			const index = session?.type === type ? session.index : typed[0].index;
+			const chosen = stored[index] ?? typed[0].entry;
+			const credential = chosen.credential;
+			const identity =
+				credential.type === "oauth"
+					? (credential.email ?? credential.accountId ?? credential.projectId ?? `cred ${chosen.id}`)
+					: `cred ${chosen.id}`;
+			return `${baseLabel} · ${type} #${chosen.id} (${identity})`;
+		};
+
+		// A deliberate OAuth login wins; then an explicit env var; then a stored static api_key.
+		const oauthSource = describeStored("oauth");
+		if (oauthSource) return oauthSource;
+		if (getEnvApiKey(provider)) return `env (over ${baseLabel})`;
+		const apiKeySource = describeStored("api_key");
+		if (apiKeySource) return apiKeySource;
+		if (this.#fallbackResolver?.(provider) !== undefined) return "fallback resolver";
+		return undefined;
 	}
 }
 

package/src/providers/__tests__/kimi-code-thinking.test.ts

@@ -0,0 +1,112 @@
+import { describe, expect, it } from "bun:test";
+import { getBundledModel } from "@oh-my-pi/pi-catalog";
+import type { Context } from "../../types";
+import type { MessageCreateParamsStreaming } from "../anthropic-wire";
+import { streamOpenAIAnthropicShim } from "../openai-anthropic-shim";
+import {
+	applyChatCompletionsCompatPolicy,
+	type OpenAICompletionsParams,
+	resolveOpenAICompatPolicy,
+} from "../openai-shared";
+
+const BASE_CHAT_COMPLETIONS_PARAMS: OpenAICompletionsParams = { messages: [], model: "unused", stream: true };
+const TITLE_CONTEXT: Context = {
+	systemPrompt: ["Generate a title."],
+	messages: [{ role: "user", content: "Explain the login failure", timestamp: 0 }],
+	tools: [
+		{
+			name: "set_title",
+			description: "Set title",
+			parameters: {
+				type: "object",
+				properties: { title: { type: "string" } },
+				required: ["title"],
+				additionalProperties: false,
+			},
+		},
+	],
+};
+
+describe("Kimi K2.7 Code thinking policy", () => {
+	it("omits disabled thinking for title-generator-style Kimi Code requests", () => {
+		const model = getBundledModel<"openai-completions">("kimi-code", "kimi-for-coding");
+		const policy = resolveOpenAICompatPolicy(model, {
+			endpoint: "chat-completions",
+			disableReasoning: true,
+			toolChoice: { type: "tool", name: "set_title" },
+		});
+		const params = { ...BASE_CHAT_COMPLETIONS_PARAMS };
+
+		applyChatCompletionsCompatPolicy(params, policy);
+
+		expect("thinking" in params).toBe(false);
+		expect(model.compat.supportsForcedToolChoice).toBe(false);
+	});
+
+	it("enables thinking and downgrades forced tool choice on Kimi Code's Anthropic endpoint", async () => {
+		const model = getBundledModel<"openai-completions">("kimi-code", "kimi-for-coding");
+		let payload: MessageCreateParamsStreaming | undefined;
+		const stream = streamOpenAIAnthropicShim(
+			model,
+			TITLE_CONTEXT,
+			{
+				apiKey: "test-key",
+				maxTokens: 1024,
+				disableReasoning: true,
+				toolChoice: { type: "tool", name: "set_title" },
+				onPayload: body => {
+					payload = body as MessageCreateParamsStreaming;
+					throw new Error("stop after payload capture");
+				},
+			},
+			{
+				anthropicBaseUrl: "https://api.kimi.com/coding",
+				defaultFormat: "anthropic",
+			},
+		);
+
+		await stream.result();
+
+		expect(payload?.thinking?.type).toBe("enabled");
+		expect(payload?.tool_choice).toEqual({ type: "auto" });
+	});
+
+	it("omits disabled thinking for native Moonshot Kimi K2.7 Code variants", () => {
+		for (const modelId of ["kimi-k2.7-code", "kimi-k2.7-code-highspeed"]) {
+			const model = getBundledModel<"openai-completions">("moonshot", modelId);
+			const policy = resolveOpenAICompatPolicy(model, {
+				endpoint: "chat-completions",
+				disableReasoning: true,
+			});
+			const params = { ...BASE_CHAT_COMPLETIONS_PARAMS };
+			applyChatCompletionsCompatPolicy(params, policy);
+
+			expect("thinking" in params).toBe(false);
+			expect(model.compat.supportsForcedToolChoice).toBe(false);
+		}
+	});
+
+	it("keeps the openai disable shape for non-native Kimi K2.7 Code aliases", () => {
+		for (const { provider, id } of [
+			{ provider: "fireworks", id: "kimi-k2.7-code" },
+			{ provider: "openrouter", id: "moonshotai/kimi-k2.7-code" },
+		] as const) {
+			const model = getBundledModel<"openai-completions">(provider, id);
+			expect(model.compat.supportsForcedToolChoice).toBe(true);
+			expect(model.compat.reasoningDisableMode).not.toBe("omit");
+		}
+	});
+
+	it("keeps explicit disabled thinking for Kimi K2.6", () => {
+		const model = getBundledModel<"openai-completions">("moonshot", "kimi-k2.6");
+		const policy = resolveOpenAICompatPolicy(model, {
+			endpoint: "chat-completions",
+			disableReasoning: true,
+		});
+		const params = { ...BASE_CHAT_COMPLETIONS_PARAMS };
+
+		applyChatCompletionsCompatPolicy(params, policy);
+
+		expect(params.thinking).toEqual({ type: "disabled" });
+	});
+});

package/src/providers/anthropic.ts

@@ -43,7 +43,6 @@ import type {
 	ToolResultMessage,
 	Usage,
 } from "../types";
-import { resolveServiceTier } from "../types";
 import { isRecord, normalizeSystemPrompts, normalizeToolCallId, resolveCacheRetention } from "../utils";
 import { createAbortSourceTracker } from "../utils/abort";
 import {
@@ -1595,7 +1594,7 @@ const streamAnthropicOnce = (
 				isOAuthToken = false;
 			} else {
 				const extraBetas = normalizeExtraBetas(options?.betas);
-				const wantsAnthropicPriority = resolveServiceTier(options?.serviceTier, model.provider) === "priority";
+				const wantsAnthropicPriority = model.provider === "anthropic" && options?.serviceTier === "priority";
 				// Skip the fast-mode beta when this session already learned the
 				// endpoint+model rejects fast mode; `speed` is dropped from the params
 				// too (dropFastMode), so the request stays a faithful non-fast request.
@@ -2191,7 +2190,8 @@ const streamAnthropicOnce = (
 					}
 					if (
 						!dropFastMode &&
-						resolveServiceTier(options?.serviceTier, model.provider) === "priority" &&
+						model.provider === "anthropic" &&
+						options?.serviceTier === "priority" &&
 						firstTokenTime === undefined &&
 						AIError.isFastModeUnsupported(streamFailure)
 					) {
@@ -2259,7 +2259,7 @@ const streamAnthropicOnce = (
 			}
 			output.duration = performance.now() - startTime;
 			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
-			if (dropFastMode && resolveServiceTier(options?.serviceTier, model.provider) === "priority") {
+			if (dropFastMode && model.provider === "anthropic" && options?.serviceTier === "priority") {
 				output.disabledFeatures = [...(output.disabledFeatures ?? []), "priority"];
 			}
 			stream.push({ type: "done", reason: output.stopReason, message: output });
@@ -2876,9 +2876,10 @@ function buildParams(
 	let thinking: MessageCreateParamsStreaming["thinking"] | undefined;
 	let outputConfigEffort: AnthropicOutputEffort | undefined;
 	if (model.reasoning) {
-		if (options?.thinkingEnabled) {
+		if (options?.thinkingEnabled || model.compat.requiresThinkingEnabled) {
+			const thinkingOptions = options ?? {};
 			const mode = model.thinking?.mode;
-			const effort = resolveAnthropicAdaptiveEffort(model, options);
+			const effort = resolveAnthropicAdaptiveEffort(model, thinkingOptions);
 			const compat = model.compat;
 			if (mode === "anthropic-adaptive" && !compat.disableAdaptiveThinking) {
 				const adaptive: { type: "adaptive"; display?: AnthropicThinkingDisplay } = { type: "adaptive" };
@@ -2889,15 +2890,15 @@ function buildParams(
 				// support: Opus 4.6 / Sonnet 4.6+ reject it with a 400, so an explicit
 				// `thinkingDisplay` MUST NOT force it onto a model that can't accept it.
 				if (model.thinking?.supportsDisplay) {
-					adaptive.display = options.thinkingDisplay ?? "summarized";
+					adaptive.display = thinkingOptions.thinkingDisplay ?? "summarized";
 				}
 				thinking = adaptive;
 				if (effort && effort !== "adaptive") outputConfigEffort = effort;
 			} else {
 				thinking = {
 					type: "enabled",
-					budget_tokens: options.thinkingBudgetTokens || 1024,
-					display: options.thinkingDisplay ?? "summarized",
+					budget_tokens: thinkingOptions.thinkingBudgetTokens || 1024,
+					display: thinkingOptions.thinkingDisplay ?? "summarized",
 				};
 				if (mode === "anthropic-budget-effort" && effort && effort !== "adaptive") outputConfigEffort = effort;
 			}
@@ -2996,7 +2997,7 @@ function buildParams(
 			seqs.length > ANTHROPIC_STOP_SEQUENCES_MAX ? seqs.slice(0, ANTHROPIC_STOP_SEQUENCES_MAX) : seqs;
 	}
 
-	if (resolveServiceTier(options?.serviceTier, model.provider) === "priority") {
+	if (model.provider === "anthropic" && options?.serviceTier === "priority") {
 		params.speed = "fast";
 	}
 

package/src/providers/google-auth.ts

@@ -13,6 +13,7 @@
  */
 
 import { Buffer } from "node:buffer";
+import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { $envpos, isEnoent, logger } from "@oh-my-pi/pi-utils";
@@ -281,6 +282,11 @@ const SHARED_TOKEN_RESOLVE_TIMEOUT_MS = 30_000;
  * The token is cached in module scope and refreshed `GOOGLE_VERTEX_REFRESH_SKEW_MS` ms before it expires.
  */
 export async function getVertexAccessToken(options?: { signal?: AbortSignal; fetch?: FetchImpl }): Promise<string> {
+	// An explicit access token (e.g. `gcloud auth print-access-token`) bypasses the cache so a
+	// refreshed env token takes effect immediately. `CLOUDSDK_AUTH_ACCESS_TOKEN` is gcloud's own
+	// override var; `GOOGLE_CLOUD_ACCESS_TOKEN` is the omp-facing alias.
+	const explicitToken = Bun.env.GOOGLE_CLOUD_ACCESS_TOKEN || Bun.env.CLOUDSDK_AUTH_ACCESS_TOKEN;
+	if (explicitToken) return explicitToken;
 	const fetchImpl = options?.fetch ?? globalThis.fetch.bind(globalThis);
 	const skew = getRefreshSkewMs();
 	const now = Date.now();
@@ -323,3 +329,22 @@ export function __resetVertexTokenCache(): void {
 	tokenCache.clear();
 	inflight.clear();
 }
+
+/**
+ * Sync best-effort probe for a usable Vertex bearer credential source — an explicit access-token
+ * env var, `GOOGLE_APPLICATION_CREDENTIALS`, a user ADC file, or a GCP runtime whose metadata
+ * server can mint ADC (GCE/Cloud Run/App Engine/Functions). Lets callers prefer the bearer
+ * Interactions transport only when ADC is actually reachable, without paying the async
+ * metadata-probe cost for API-key-only setups.
+ */
+export function hasVertexBearerCredentialsHint(): boolean {
+	if (Bun.env.GOOGLE_CLOUD_ACCESS_TOKEN || Bun.env.CLOUDSDK_AUTH_ACCESS_TOKEN) return true;
+	if (Bun.env.GOOGLE_APPLICATION_CREDENTIALS) return true;
+	// GCP-hosted runtimes expose ADC via the metadata server; these env vars mark those runtimes.
+	if (Bun.env.K_SERVICE || Bun.env.FUNCTION_TARGET || Bun.env.GAE_ENV || Bun.env.GCE_METADATA_HOST) return true;
+	try {
+		return fs.existsSync(userAdcPath());
+	} catch {
+		return false;
+	}
+}

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

@@ -35,6 +35,7 @@ import { armPreResponseTimeout, getStreamFirstEventTimeoutMs } from "../utils/id
 // Refresh is the sole responsibility of AuthStorage (broker-aware, single-flighted);
 // the stream provider trusts the access token threaded through `options.apiKey`.
 import { normalizeSchemaForCCA } from "../utils/schema";
+import { StreamMarkupHealing, type StreamMarkupHealingEvent } from "../utils/stream-markup-healing";
 import type { Content, FunctionCallingConfigMode, ThinkingConfig } from "./google-shared";
 import {
 	convertMessages,
@@ -665,15 +666,43 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 				let currentBlock: TextContent | ThinkingContent | null = null;
 				const blocks = output.content;
 				const blockIndex = () => blocks.length - 1;
+				const visibleTextHealing = new StreamMarkupHealing({ pattern: "thinking" });
 
 				let isBuffering = false;
 				let textBuffer = "";
 				let bufferedTextSignature: string | undefined;
 
-				const emitVisibleText = (delta: string, thoughtSignature?: string) => {
-					if (!delta || !currentBlock || currentBlock.type !== "text") return;
-					currentBlock.text += delta;
-					currentBlock.textSignature = retainThoughtSignature(currentBlock.textSignature, thoughtSignature);
+				const endCurrentBlock = (): void => {
+					if (!currentBlock) return;
+					pushBlockEndEvent(currentBlock, blockIndex(), output, stream);
+					currentBlock = null;
+				};
+
+				const startTextBlock = (): TextContent => {
+					let block = currentBlock;
+					if (block?.type !== "text") {
+						endCurrentBlock();
+						block = startTextOrThinkingBlock(false, output, stream, ensureStarted);
+						currentBlock = block;
+					}
+					return block;
+				};
+
+				const startThinkingBlock = (): ThinkingContent => {
+					let block = currentBlock;
+					if (block?.type !== "thinking") {
+						endCurrentBlock();
+						block = startTextOrThinkingBlock(true, output, stream, ensureStarted);
+						currentBlock = block;
+					}
+					return block;
+				};
+
+				const emitVisibleText = (delta: string, thoughtSignature?: string): void => {
+					if (!delta) return;
+					const block = startTextBlock();
+					block.text += delta;
+					block.textSignature = retainThoughtSignature(block.textSignature, thoughtSignature);
 					stream.push({
 						type: "text_delta",
 						contentIndex: blockIndex(),
@@ -682,6 +711,48 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 					});
 				};
 
+				const emitVisibleThinking = (delta: string): void => {
+					if (!delta) return;
+					const block = startThinkingBlock();
+					block.thinking += delta;
+					stream.push({
+						type: "thinking_delta",
+						contentIndex: blockIndex(),
+						delta,
+						partial: output,
+					});
+				};
+
+				const emitHealingEvent = (event: StreamMarkupHealingEvent, thoughtSignature?: string): void => {
+					if (event.type === "text") {
+						emitVisibleText(event.text, thoughtSignature);
+					} else if (event.type === "thinking") {
+						emitVisibleThinking(event.thinking);
+					}
+				};
+
+				const feedVisibleText = (delta: string, thoughtSignature?: string): void => {
+					for (const event of visibleTextHealing.feedEvents(delta)) {
+						emitHealingEvent(event, thoughtSignature);
+					}
+				};
+
+				const flushVisibleText = (thoughtSignature?: string): void => {
+					for (const event of visibleTextHealing.flushEvents()) {
+						emitHealingEvent(event, thoughtSignature);
+					}
+				};
+
+				const retainCurrentBlockThoughtSignature = (thoughtSignature: string): void => {
+					const block = currentBlock;
+					if (!block) return;
+					if (block.type === "thinking") {
+						block.thinkingSignature = retainThoughtSignature(block.thinkingSignature, thoughtSignature);
+					} else {
+						block.textSignature = retainThoughtSignature(block.textSignature, thoughtSignature);
+					}
+				};
+
 				for await (const chunk of readSseJson<CloudCodeAssistResponseChunk>(
 					activeResponse.body!,
 					options?.signal,
@@ -710,20 +781,12 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 						for (const part of candidate.content.parts) {
 							if (part.text !== undefined && part.text !== "") {
 								const isThinking = isThinkingPart(part);
-								if (
-									!currentBlock ||
-									(isThinking && currentBlock.type !== "thinking") ||
-									(!isThinking && currentBlock.type !== "text")
-								) {
-									if (currentBlock) {
-										pushBlockEndEvent(currentBlock, blockIndex(), output, stream);
-									}
-									currentBlock = startTextOrThinkingBlock(isThinking, output, stream, ensureStarted);
-								}
-								if (currentBlock.type === "thinking") {
-									currentBlock.thinking += part.text;
-									currentBlock.thinkingSignature = retainThoughtSignature(
-										currentBlock.thinkingSignature,
+								if (isThinking) {
+									flushVisibleText();
+									const block = startThinkingBlock();
+									block.thinking += part.text;
+									block.thinkingSignature = retainThoughtSignature(
+										block.thinkingSignature,
 										part.thoughtSignature,
 									);
 									stream.push({
@@ -744,7 +807,7 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 										textBuffer = part.text;
 										bufferedTextSignature = part.thoughtSignature;
 									} else {
-										emitVisibleText(part.text, part.thoughtSignature);
+										feedVisibleText(part.text, part.thoughtSignature);
 									}
 
 									if (isBuffering) {
@@ -757,32 +820,19 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 											isBuffering = false;
 											textBuffer = "";
 											bufferedTextSignature = undefined;
-											emitVisibleText(buffered.visibleText, visibleSignature);
+											feedVisibleText(buffered.visibleText, visibleSignature);
 										}
 									}
 								}
-							} else if (part.text === "" && part.thoughtSignature && currentBlock && !part.functionCall) {
-								if (currentBlock.type === "thinking") {
-									currentBlock.thinkingSignature = retainThoughtSignature(
-										currentBlock.thinkingSignature,
-										part.thoughtSignature,
-									);
-								} else {
-									currentBlock.textSignature = retainThoughtSignature(
-										currentBlock.textSignature,
-										part.thoughtSignature,
-									);
-								}
+							} else if (part.text === "" && part.thoughtSignature && !part.functionCall) {
+								retainCurrentBlockThoughtSignature(part.thoughtSignature);
 							}
 
 							if (part.functionCall) {
-								if (currentBlock) {
-									pushBlockEndEvent(currentBlock, blockIndex(), output, stream);
-									currentBlock = null;
-								}
+								flushVisibleText();
+								endCurrentBlock();
 								isBuffering = false;
 								textBuffer = "";
-
 								const providedId = part.functionCall.id;
 								const needsNewId =
 									!providedId || output.content.some(b => b.type === "toolCall" && b.id === providedId);
@@ -848,16 +898,15 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 						sawLeak = true;
 					}
 					if (buffered.kind !== "incomplete") {
-						emitVisibleText(buffered.visibleText, bufferedTextSignature);
+						feedVisibleText(buffered.visibleText, bufferedTextSignature);
 					}
 					bufferedTextSignature = undefined;
 					isBuffering = false;
 					textBuffer = "";
 				}
 
-				if (currentBlock) {
-					pushBlockEndEvent(currentBlock, blockIndex(), output, stream);
-				}
+				flushVisibleText(bufferedTextSignature);
+				endCurrentBlock();
 
 				return hasMeaningfulGoogleContent(output) || sawLeak;
 			};