@oh-my-pi/pi-ai 16.3.6 → 16.3.8

package/dist/types/usage/github-copilot.d.ts

@@ -3,5 +3,5 @@
  *
  * Normalizes Copilot quota usage into the shared UsageReport schema.
  */
-import type { UsageProvider } from "../usage";
+import type { UsageProvider } from "../usage.js";
 export declare const githubCopilotUsageProvider: UsageProvider;

package/dist/types/usage/google-antigravity.d.ts

@@ -1,4 +1,4 @@
-import type { CredentialRankingStrategy, UsageProvider } from "../usage";
+import type { CredentialRankingStrategy, UsageProvider } from "../usage.js";
 export declare const antigravityUsageProvider: UsageProvider;
 /**
  * Antigravity quotas are returned per backend counter (Anthropic / Google /

package/dist/types/usage/kimi.d.ts

@@ -1,2 +1,2 @@
-import type { UsageProvider } from "../usage";
+import type { UsageProvider } from "../usage.js";
 export declare const kimiUsageProvider: UsageProvider;

package/dist/types/usage/minimax-code.d.ts

@@ -1,2 +1,2 @@
-import type { UsageProvider } from "../usage";
+import type { UsageProvider } from "../usage.js";
 export declare const minimaxCodeUsageProvider: UsageProvider;

package/dist/types/usage/ollama.d.ts

@@ -1,4 +1,4 @@
-import type { UsageProvider } from "../usage";
+import type { UsageProvider } from "../usage.js";
 /** Registers Ollama accounts with usage views even though no quota endpoint is exposed. */
 export declare const ollamaUsageProvider: UsageProvider;
 /** Registers Ollama Cloud accounts with usage views until a quota endpoint is available. */

package/dist/types/usage/openai-codex-reset.d.ts

@@ -18,7 +18,7 @@
  * (the `/usage reset` command + auto-redeem) and any out-of-band tooling can
  * share one wire contract.
  */
-import type { FetchImpl } from "../types";
+import type { FetchImpl } from "../types.js";
 /** A single redeemable (or already-spent) saved reset. */
 export interface CodexResetCredit {
     /** Opaque credit id, e.g. `RateLimitResetCredit_…`. Pass to {@link consumeCodexResetCredit}. */

package/dist/types/usage/openai-codex.d.ts

@@ -1,3 +1,3 @@
-import type { CredentialRankingStrategy, UsageProvider } from "../usage";
+import type { CredentialRankingStrategy, UsageProvider } from "../usage.js";
 export declare const openaiCodexUsageProvider: UsageProvider;
 export declare const codexRankingStrategy: CredentialRankingStrategy;

package/dist/types/usage/opencode-go.d.ts

@@ -1,2 +1,2 @@
-import type { UsageProvider } from "../usage";
+import type { UsageProvider } from "../usage.js";
 export declare const opencodeGoUsageProvider: UsageProvider;

package/dist/types/usage/zai.d.ts

@@ -1,2 +1,2 @@
-import type { UsageProvider } from "../usage";
+import type { UsageProvider } from "../usage.js";
 export declare const zaiUsageProvider: UsageProvider;

package/dist/types/usage.d.ts

@@ -1,4 +1,4 @@
-import type { FetchImpl, Provider } from "./types";
+import type { FetchImpl, Provider } from "./types.js";
 export type UsageUnit = "percent" | "tokens" | "requests" | "usd" | "minutes" | "bytes" | "unknown";
 export type UsageStatus = "ok" | "warning" | "exhausted" | "unknown";
 /** Time window for a limit (e.g. 5h, 7d, monthly). */

package/dist/types/utils/block-symbols.d.ts

@@ -34,3 +34,18 @@ export declare const kCursorExecResolved: unique symbol;
 export type CursorExecResolvedCarrier = object & {
     [kCursorExecResolved]?: true;
 };
+/**
+ * Marks a text block synthesized by cross-model thinking demotion in
+ * `transformMessages`. Converters that flatten adjacent text blocks into one
+ * string (openai-completions) insert a paragraph separator after marked
+ * blocks; unmarked adjacent blocks keep their original byte sequence.
+ * Symbol-keyed so the marker never persists across the JSONL round-trip and
+ * never reaches the wire.
+ */
+export declare const kDemotedThinking: unique symbol;
+/** Carries the demoted-thinking marker without exposing a string-keyed property. */
+export type DemotedThinkingCarrier = object & {
+    [kDemotedThinking]?: boolean;
+};
+/** True for text blocks synthesized by cross-model thinking demotion. */
+export declare function isDemotedThinking(block: DemotedThinkingCarrier | null | undefined): boolean;

package/dist/types/utils/empty-completion-retry.d.ts

@@ -1,5 +1,5 @@
-import type { AssistantMessage, Context } from "../types";
-import { AssistantMessageEventStream } from "./event-stream";
+import type { AssistantMessage, Context } from "../types.js";
+import { AssistantMessageEventStream } from "./event-stream.js";
 export declare const MAX_EMPTY_COMPLETION_RETRIES = 2;
 export declare const EMPTY_COMPLETION_BASE_DELAY_MS = 500;
 /**

package/dist/types/utils/event-stream.d.ts

@@ -1,4 +1,4 @@
-import type { AssistantMessage, AssistantMessageEvent } from "../types";
+import type { AssistantMessage, AssistantMessageEvent } from "../types.js";
 export declare class EventStream<T, R = T> implements AsyncIterable<T> {
     #private;
     queue: T[];

package/dist/types/utils/harmony-leak.d.ts

@@ -7,7 +7,7 @@
  * hashline DSL form. Other tools and surfaces fall through to
  * abort-and-retry handled by the agent loop.
  */
-import type { AssistantMessage, Model, ToolCall } from "../types";
+import type { AssistantMessage, Model, ToolCall } from "../types.js";
 declare const SIGNAL_ORDER: readonly ["M", "C", "G", "S", "B", "R", "T"];
 export type HarmonySignalClass = "H" | (typeof SIGNAL_ORDER)[number];
 export type HarmonySurface = "assistant_text" | "assistant_thinking" | "tool_arg";

package/dist/types/utils/http-inspector.d.ts

@@ -13,6 +13,25 @@ export type CapturedHttpErrorResponse = {
     bodyText?: string;
     bodyJson?: unknown;
 };
+/**
+ * Build the JSON persisted for a rejected request. Request fields stay at the
+ * top level (so existing dump parsers still read `body`); the provider's error
+ * is added under `errorResponse` so a failed request is diagnosable from the
+ * dump file rather than the request alone.
+ */
+export declare function buildHttp400DumpPayload(dump: RawHttpRequestDump, error: unknown, message: string): RawHttpRequestDump & {
+    errorResponse: {
+        status: number | undefined;
+        message: string;
+    };
+};
+/** HTTP statuses whose rejected request we persist for post-hoc diagnosis: the
+ *  request-content rejections that wedge a session. 400 (bad request) and 413
+ *  (payload too large — an oversized image / snapcompact frame payload that 413s
+ *  and empties the turn). Auth (401/403), not-found (404), rate limits and 5xx
+ *  are excluded: 429/5xx are retried, so persisting them here would write one
+ *  dump per attempt. */
+export declare function shouldDumpRejectedRequest(error: unknown): boolean;
 export declare function appendRawHttpRequestDumpFor400(message: string, error: unknown, dump: RawHttpRequestDump | undefined): Promise<string>;
 export declare function finalizeErrorMessage(error: unknown, rawRequestDump: RawHttpRequestDump | undefined, capturedErrorResponse?: CapturedHttpErrorResponse): Promise<string>;
 /**

package/dist/types/utils/leaked-thinking-stream.d.ts

@@ -24,7 +24,7 @@
  * `../dialect/owned-stream.ts`, minus all in-band tool-call grammar: tool-call
  * events are forwarded verbatim.
  */
-import { AssistantMessageEventStream } from "./event-stream";
+import { AssistantMessageEventStream } from "./event-stream.js";
 /**
  * Wrap a provider stream so leaked reasoning fences are healed into thinking
  * blocks live, for every provider. Returns a new stream that re-projects the

package/dist/types/utils/openai-http.d.ts

@@ -15,10 +15,10 @@
  *   chain-state detectors, which regex over `error.message`.
  */
 import { type SseEventObserver } from "@oh-my-pi/pi-utils";
-import * as AIError from "../error";
-import { OpenAIHttpError } from "../error";
+import * as AIError from "../error/index.js";
+import { OpenAIHttpError } from "../error/index.js";
 export { OpenAIHttpError };
-import type { FetchImpl } from "../types";
+import type { FetchImpl } from "../types.js";
 export interface OpenAIStreamRequestInit {
     url: string;
     headers: Record<string, string>;
@@ -26,12 +26,6 @@ export interface OpenAIStreamRequestInit {
     body: unknown;
     signal: AbortSignal;
     fetch?: FetchImpl;
-    /**
-     * Total attempts (initial + retries). Defaults to {@link DEFAULT_MAX_ATTEMPTS}.
-     * Pass `1` when a first-event watchdog is armed so retries cannot silently
-     * extend the caller's deadline (mirrors the old `maxRetries: 0` hint).
-     */
-    maxAttempts?: number;
     /** Raw wire-frame observer (`onSseEvent` debug pipeline). */
     onSseEvent?: SseEventObserver;
 }

package/dist/types/utils/provider-response.d.ts

@@ -1,3 +1,3 @@
-import type { Api, Model, ProviderResponseMetadata, StreamOptions } from "../types";
+import type { Api, Model, ProviderResponseMetadata, StreamOptions } from "../types.js";
 export declare function normalizeProviderResponse(response: Response, requestId?: string | null, metadata?: Record<string, unknown>): ProviderResponseMetadata;
 export declare function notifyProviderResponse(options: Pick<StreamOptions, "onResponse"> | undefined, response: Response, model?: Model<Api>, requestId?: string | null, metadata?: Record<string, unknown>): Promise<void>;

package/dist/types/utils/proxy.d.ts

@@ -1,5 +1,5 @@
 import * as tls from "node:tls";
-import type { FetchImpl } from "../types";
+import type { FetchImpl } from "../types.js";
 /**
  * Checks if a host is local or cloud metadata, which should always bypass the proxy
  * (e.g. localhost, 127/8, ::1, 169.254.169.254, metadata.google.internal).

package/dist/types/utils/request-debug.d.ts

@@ -1,4 +1,4 @@
-import type { FetchImpl } from "../types";
+import type { FetchImpl } from "../types.js";
 export type RequestDebugHeaders = Headers | Record<string, string | string[] | number | undefined | null> | undefined;
 export interface RequestDebugPayload {
     method: string;

package/dist/types/utils/retry.d.ts

@@ -1,4 +1,4 @@
-import { isCopilotTransientModelError } from "../error/flags";
+import { isCopilotTransientModelError } from "../error/flags.js";
 export { isCopilotTransientModelError };
 /**
  * Wrap an initial Copilot request so transient `model_not_supported` 400s are

package/dist/types/utils/schema/equality.d.ts

@@ -1,4 +1,4 @@
-import type { JsonObject } from "./types";
+import type { JsonObject } from "./types.js";
 export declare function areJsonValuesEqual(left: unknown, right: unknown): boolean;
 export declare function mergeCompatibleEnumSchemas(existing: unknown, incoming: unknown): JsonObject | null;
 export declare function mergePropertySchemas(existing: unknown, incoming: unknown): unknown;

package/dist/types/utils/schema/index.d.ts

@@ -1,15 +1,15 @@
-export * from "./adapt";
-export * from "./compatibility";
-export * from "./dereference";
-export * from "./draft";
-export * from "./equality";
-export * from "./fields";
-export * from "./json-schema-validator";
-export * from "./meta-validator";
-export * from "./normalize";
-export * from "./spill";
-export * from "./strict-tool-validation";
-export * from "./types";
-export * from "./typescript";
-export * from "./wire";
-export * from "./zod-decontaminate";
+export * from "./adapt.js";
+export * from "./compatibility.js";
+export * from "./dereference.js";
+export * from "./draft.js";
+export * from "./equality.js";
+export * from "./fields.js";
+export * from "./json-schema-validator.js";
+export * from "./meta-validator.js";
+export * from "./normalize.js";
+export * from "./spill.js";
+export * from "./strict-tool-validation.js";
+export * from "./types.js";
+export * from "./typescript.js";
+export * from "./wire.js";
+export * from "./zod-decontaminate.js";

package/dist/types/utils/schema/normalize.d.ts

@@ -1,5 +1,5 @@
-import { type DescriptionSpillFormat } from "./spill";
-import { type JsonObject } from "./types";
+import { type DescriptionSpillFormat } from "./spill.js";
+import { type JsonObject } from "./types.js";
 export type ResidualSchemaIncompatibility = "type-array" | "type-null" | "nullable" | "combiners";
 export interface NormalizeSchemaOptions {
     unsupportedFields: (key: string) => boolean;

package/dist/types/utils/schema/spill.d.ts

@@ -1,4 +1,4 @@
-import type { JsonObject } from "./types";
+import type { JsonObject } from "./types.js";
 export type DescriptionSpillFormat = "spill" | "paren";
 /**
  * Demote stripped JSON Schema keywords into a node's `description` so the model

package/dist/types/utils/schema/wire.d.ts

@@ -12,7 +12,7 @@
  */
 import type { Type } from "arktype";
 import { type ZodType } from "zod/v4";
-import type { Tool } from "../../types";
+import type { Tool } from "../../types.js";
 /**
  * True when `value` is a live Zod schema instance.
  *

package/dist/types/utils/sse-debug.d.ts

@@ -1,5 +1,5 @@
 import type { ServerSentEvent } from "@oh-my-pi/pi-utils";
-import type { RawSseEvent } from "../types";
+import type { RawSseEvent } from "../types.js";
 type RawSseObserver = (event: RawSseEvent) => void;
 export declare function notifyRawSseEvent(observer: RawSseObserver | undefined, event: ServerSentEvent | RawSseEvent): void;
 export {};

package/dist/types/utils/thinking-loop.d.ts

@@ -1,5 +1,5 @@
-import type { Api, Model, StreamOptions } from "../types";
-import { AssistantMessageEventStream } from "./event-stream";
+import type { Api, Model, StreamOptions } from "../types.js";
+import { AssistantMessageEventStream } from "./event-stream.js";
 /** Stable lead phrase of the guard's error message; exported for tests. The
  *  message also carries "stream stall" so the session + transport retry
  *  classifiers treat it as a transient (retryable) stop without bespoke rules. */

package/dist/types/utils/tool-call-loop-guard.d.ts

@@ -1,4 +1,4 @@
-import type { AssistantMessage, ToolResultMessage } from "../types";
+import type { AssistantMessage, ToolResultMessage } from "../types.js";
 /** Runtime settings for cross-turn tool-call repetition detection. */
 export interface ToolCallLoopGuardOptions {
     readonly threshold: number;

package/dist/types/utils/tool-choice.d.ts

@@ -1,7 +1,7 @@
 /**
  * Utility functions for mapping unified ToolChoice to provider-specific formats.
  */
-import type { ToolChoice } from "../types";
+import type { ToolChoice } from "../types.js";
 /** OpenAI Completions API tool choice format */
 export type OpenAICompletionsToolChoice = "auto" | "none" | "required" | {
     type: "function";

package/dist/types/utils/validation.d.ts

@@ -1,4 +1,4 @@
-import type { Tool, ToolCall } from "../types";
+import type { Tool, ToolCall } from "../types.js";
 /**
  * Finds a tool by name and validates the tool call arguments against its schema.
  * @param tools Array of tool definitions

package/dist/types/utils.d.ts

@@ -1,5 +1,5 @@
-import type { ResponseInput } from "./providers/openai-responses-wire";
-import type { CacheRetention, OpenAIResponsesHistoryPayload, ProviderPayload } from "./types";
+import type { ResponseInput } from "./providers/openai-responses-wire.js";
+import type { CacheRetention, OpenAIResponsesHistoryPayload, ProviderPayload } from "./types.js";
 export { isRecord } from "@oh-my-pi/pi-utils";
 export declare function normalizeSystemPrompts(systemPrompt: readonly string[] | string | undefined | null): string[];
 export declare function normalizeToolCallId(id: string): string;
@@ -14,6 +14,18 @@ export declare function normalizeResponsesToolCallId(id: string, itemPrefix?: Re
  */
 export declare function truncateResponseItemId(id: string, prefix: string): string;
 export declare function sanitizeOpenAIResponsesHistoryItemsForReplay(items: Array<Record<string, unknown>>): ResponseInput;
+/**
+ * Sanitize assistant-native Responses history for replay.
+ *
+ * Returns `undefined` for hidden-empty turns that only contain reasoning and an
+ * empty assistant message, allowing callers to rebuild visible transcript
+ * history instead of replaying stale native state.
+ */
+export declare function sanitizeOpenAIResponsesAssistantHistoryItemsForReplay(items: Array<Record<string, unknown>>): ResponseInput | undefined;
+/**
+ * Drop hidden-only fallback assistant replay after a native Responses snapshot is rejected.
+ */
+export declare function sanitizeOpenAIResponsesAssistantFallbackItemsForReplay(items: ResponseInput): ResponseInput;
 export declare function createOpenAIResponsesHistoryPayload(provider: string, items: Array<Record<string, unknown>>, incremental?: boolean): OpenAIResponsesHistoryPayload;
 export declare function getOpenAIResponsesHistoryPayload(providerPayload: ProviderPayload | undefined, currentProvider: string, fallbackProvider?: string): OpenAIResponsesHistoryPayload | undefined;
 export declare function getOpenAIResponsesHistoryItems(providerPayload: ProviderPayload | undefined, currentProvider: string, fallbackProvider?: string): Array<Record<string, unknown>> | undefined;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "16.3.6",
+	"version": "16.3.8",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -38,9 +38,9 @@
 	},
 	"dependencies": {
 		"@bufbuild/protobuf": "^2.12.0",
-		"@oh-my-pi/pi-catalog": "16.3.6",
-		"@oh-my-pi/pi-utils": "16.3.6",
-		"@oh-my-pi/pi-wire": "16.3.6",
+		"@oh-my-pi/pi-catalog": "16.3.8",
+		"@oh-my-pi/pi-utils": "16.3.8",
+		"@oh-my-pi/pi-wire": "16.3.8",
 		"arktype": "^2.2.0",
 		"zod": "^4"
 	},

package/src/dialect/demotion.ts

@@ -1,28 +1,28 @@
-import { bareModelId, preferredDialect } from "@oh-my-pi/pi-catalog/identity";
+import { preferredDialect } from "@oh-my-pi/pi-catalog/identity";
 import { getDialectDefinition } from "./factory";
 
-const CLAUDE_FABLE_ID = /(?:^|[./])claude[-.]fable(?:[-.]|$)/i;
-
 /**
  * Wrap a prior-turn reasoning string for demotion into native conversation
- * history — the cross-provider / cross-model case where the target cannot replay
- * it as a structured thinking block (verified end-to-end against Gemini 3: a
- * replayed unsigned `thought` part is schema-accepted but silently discarded —
- * neither recalled nor influencing generation).
+ * history — the cross-provider / cross-model case where the target cannot
+ * replay it as a structured thinking block (verified end-to-end against Gemini
+ * 3: a replayed unsigned `thought` part is schema-accepted but silently
+ * discarded — neither recalled nor influencing generation).
  *
- * Fable is the exception: Anthropic's `reasoning_extraction` classifier blocks
- * requests that replay prior reasoning inside `<thinking>` / `antml:thinking`
- * tags OR the older `_Hmm. …_` italic envelope — it reads the wrapped
- * chain-of-thought as an attempt to duplicate model outputs and refuses the
- * whole turn. Fable therefore receives prior reasoning as bare assistant prose:
- * no tag, no `_Hmm.` wrapper, no trailing newline.
+ * The Anthropic/Claude dialect is the primary exception: Anthropic's
+ * `reasoning_extraction` classifier blocks requests that replay prior
+ * reasoning inside `<thinking>` / `antml:thinking` tags — it reads the
+ * wrapped chain-of-thought as an attempt to duplicate model outputs and
+ * refuses (Fable) or leaks it as visible reasoning (Opus / Sonnet / Haiku /
+ * Mythos). Every Anthropic-dialect Claude model therefore receives prior
+ * reasoning as bare assistant prose: no tag, no wrapper, no trailing newline.
  * Heat is cumulative (block count and early-conversation position also raise
  * it), so this lowers per-block signal but does not license unbounded replay.
- * Harmony and Gemma are also exceptions: their `renderThinking` emits
+ *
+ * Harmony and Gemma are the other exceptions: their `renderThinking` emits
  * chat-template control tokens (`<|channel|>analysis`, `<|channel>thought`)
- * that must not appear inside a structured native message, so they fall back to
- * a plain `<think>` block. Every other dialect's thinking form is inline-safe
- * XML tags or a markdown fence.
+ * that must not appear inside a structured native message, so they fall back
+ * to a plain `<think>` block. Every other dialect's thinking form is
+ * inline-safe XML tags or a markdown fence.
  *
  * The result does not append a delimiter; callers that flatten adjacent blocks
  * into a single string must insert their own separator.
@@ -33,9 +33,8 @@ const CLAUDE_FABLE_ID = /(?:^|[./])claude[-.]fable(?:[-.]|$)/i;
 export function renderDemotedThinking(modelId: string, text: string): string {
 	if (!text) return "";
 	text = text.toWellFormed();
-	const canonicalId = bareModelId(modelId);
 	const dialect = preferredDialect(modelId);
-	if (CLAUDE_FABLE_ID.test(canonicalId)) return text;
+	if (dialect === "anthropic") return text;
 	if (dialect === "harmony" || dialect === "gemma") return `<think>\n${text}\n</think>`;
 	return getDialectDefinition(dialect).renderThinking(text);
 }

package/src/error/rate-limit.ts

@@ -100,7 +100,7 @@ export function calculateRateLimitBackoffMs(reason: RateLimitReason): number {
 
 /** Detect usage/quota limit errors in error messages (persistent, requires credential switch). */
 const USAGE_LIMIT_PATTERN =
-	/usage.?limit|usage_limit_reached|usage_not_included|limit_reached|quota.?exceeded|quota.?reached|resource.?exhausted|exhausted your capacity|quota will reset|insufficient.?(?:balance|quota)/i;
+	/usage.?limit|usage_limit_reached|usage_not_included|limit_reached|quota.?(?:exceeded|reached|insufficient)|额度不足|额度耗尽|resource.?exhausted|exhausted your capacity|quota will reset|insufficient.?(?:balance|quota)/i;
 
 /**
  * HTTP status codes that, absent richer body classification, represent an

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

@@ -170,8 +170,9 @@ export const streamAzureOpenAIResponses: StreamFunction<"azure-openai-responses"
 						body: params,
 						signal: requestSignal,
 						fetch: options?.fetch,
-						// Watchdog armed → no retries, so they cannot silently extend the deadline.
-						maxAttempts: requestTimeoutMs !== undefined ? 1 : undefined,
+						// Transient 408/429/5xx get Retry-After-aware transport retries;
+						// the first-event watchdog aborts `requestSignal`, so retries
+						// cannot extend the caller's deadline.
 						onSseEvent: rawSseObserver,
 					});
 					openaiStream = handle.events;

package/src/providers/cursor.ts

@@ -1111,6 +1111,17 @@ async function handleExecServerMessage(
 		case "grepArgs": {
 			const args = execMsg.message.value;
 			if (!args.toolCallId) args.toolCallId = crypto.randomUUID();
+			// Cursor's model sometimes emits `grepArgs` with an empty `pattern` and a
+			// non-empty `glob`, expecting grep to list files matching the glob. Reject
+			// that up front with an actionable error so the model retries with a real
+			// regex or switches to `ls`/`read`, instead of the local grep tool
+			// surfacing a bare "Pattern must not be empty" (issue #4574) after the
+			// synthesized block has already been persisted with a placeholder pattern.
+			const emptyPatternError = emptyGrepPatternRejection(args.pattern, args.glob);
+			if (emptyPatternError !== null) {
+				sendExecClientMessage(h2Request, execMsg, "grepResult", buildGrepErrorResult(emptyPatternError));
+				return;
+			}
 			// Mirror the coding-agent bridge's arg mapping so live UI (from
 			// `tool_execution_start`) and rebuilt transcript (from this block)
 			// display identical args.
@@ -1835,6 +1846,31 @@ function buildGrepErrorResult(error: string) {
 	});
 }
 
+/**
+ * Reject a Cursor exec-channel `grepArgs` frame whose `pattern` is empty or
+ * whitespace-only. Returns an actionable error message when the pattern is
+ * unusable (with a `glob`-aware hint when the model likely meant to list
+ * files), or `null` when the pattern is valid and grep should run.
+ *
+ * Exported for tests. Cursor's model sometimes sends `pattern=""` together
+ * with a non-empty `glob`, expecting grep to enumerate matching files; the
+ * downstream coding-agent `grep` tool rejects that with a bare "Pattern must
+ * not be empty", which the TUI renders as `?` in the tool preview (issue
+ * #4574). Handling it at the Cursor exec dispatch keeps the synthesized
+ * `toolCall` block off the persisted assistant message and gives the model a
+ * specific recovery hint.
+ */
+export function emptyGrepPatternRejection(pattern: string | undefined, glob: string | undefined): string | null {
+	if (pattern && pattern.trim().length > 0) return null;
+	if (glob && glob.length > 0) {
+		return (
+			`grep pattern is required (received an empty pattern). To list files matching "${glob}", ` +
+			`pass a non-empty regex (e.g. ".") and set path to that glob, or use the ls/read tool instead.`
+		);
+	}
+	return "grep pattern is required (received an empty pattern).";
+}
+
 function buildDiagnosticsResultFromToolResult(path: string, toolResult: ToolResultMessage) {
 	const text = toolResultToText(toolResult);
 	if (toolResult.isError) {

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

@@ -263,6 +263,8 @@ export interface GoogleGeminiCliOptions extends StreamOptions {
 		 */
 		suppress?: { level: GoogleThinkingLevel } | { budget: number };
 	};
+	/** Request that Cloud Code Assist omit human-readable thought summaries while still allowing internal reasoning. */
+	hideThinkingSummary?: boolean;
 	/**
 	 * Upstream wire model id override for collapsed effort-tier variants.
 	 * Serialized as `requestModelId ?? model.requestModelId ?? model.id`.
@@ -1002,8 +1004,8 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 						}
 
 						const streamed = await streamResponse(currentResponse);
-						if (streamed) {
-							receivedContent = true;
+						if (output.stopReason !== "stop" || streamed) {
+							receivedContent = streamed;
 							break;
 						}
 
@@ -1012,6 +1014,13 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 						}
 					}
 
+					if (output.stopReason === "aborted" || output.stopReason === "error") {
+						throw new AIError.ProviderResponseError(output.errorMessage ?? "An unknown error occurred", {
+							provider: model.provider,
+							kind: "output",
+						});
+					}
+
 					if (!receivedContent) {
 						throw new AIError.ProviderResponseError("Cloud Code Assist API returned an empty response", {
 							provider: model.provider,
@@ -1242,7 +1251,7 @@ export function buildRequest(
 	// Thinking config
 	if (options.thinking?.enabled && model.reasoning) {
 		generationConfig.thinkingConfig = {
-			includeThoughts: true,
+			includeThoughts: !options.hideThinkingSummary,
 		};
 		// Gemini 3 models use thinkingLevel, older models use thinkingBudget
 		if (options.thinking.level !== undefined) {

package/src/providers/google-shared.ts

@@ -75,6 +75,8 @@ export interface GoogleSharedStreamOptions extends StreamOptions {
 		budgetTokens?: number;
 		level?: GoogleThinkingLevel;
 	};
+	/** Request that Google omit human-readable thought summaries while still allowing internal reasoning. */
+	hideThinkingSummary?: boolean;
 	/** Gemini/Vertex serving tier (`flex`/`priority`); other values are omitted. */
 	serviceTier?: ServiceTier;
 	/**
@@ -859,7 +861,7 @@ export function buildGoogleGenerateContentParams<T extends "google-generative-ai
 	}
 
 	if (options.thinking?.enabled && model.reasoning) {
-		const cfg: ThinkingConfig = { includeThoughts: true };
+		const cfg: ThinkingConfig = { includeThoughts: !options.hideThinkingSummary };
 		if (options.thinking.level !== undefined) {
 			// GoogleThinkingLevel mirrors the SDK's `ThinkingLevel` string enum values 1:1.
 			cfg.thinkingLevel = options.thinking.level as ThinkingLevel;

package/src/providers/mock.ts

@@ -446,10 +446,17 @@ function mergeUsage(partial?: Partial<Omit<Usage, "cost">> & { cost?: Partial<Us
 	if (costProvided) {
 		merged.cost = { ...base.cost, ...partial.cost } as Usage["cost"];
 	}
-	// Recompute totalTokens when not explicitly provided (canonical formula matches types.ts:
-	// input + output + cacheRead + cacheWrite).
+	// Recompute totalTokens when not explicitly provided (canonical formula matches types.ts).
 	if (partial.totalTokens === undefined) {
-		merged.totalTokens = merged.input + merged.output + merged.cacheRead + merged.cacheWrite;
+		const orchestration = merged.orchestration;
+		merged.totalTokens =
+			merged.input +
+			merged.output +
+			merged.cacheRead +
+			merged.cacheWrite +
+			(orchestration?.input ?? 0) +
+			(orchestration?.output ?? 0) +
+			(orchestration?.cacheRead ?? 0);
 	}
 	// Recompute cost.total when cost components were supplied without an explicit total.
 	if (costProvided && partial.cost?.total === undefined) {