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

package/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 ## [Unreleased]
 
+## [16.2.7] - 2026-06-30
+
+### Added
+
+- Added service tier support for Google Gemini and Vertex AI, including model-specific service tier configurations via ServiceTierByFamily.
+- Added Google Vertex AI Interactions API support for Gemini 3+ models by default, with automatic fallback to :streamGenerateContent and a useInteractionsApi: false option to force standard generation.
+- Added support for explicit Vertex bearer access tokens via GOOGLE_CLOUD_ACCESS_TOKEN or CLOUDSDK_AUTH_ACCESS_TOKEN environment variables.
+
+### Changed
+
+- Updated service tier logic to use per-provider configurations instead of global scopes.
+- Refactored priority request billing and accounting to better align with specific provider capabilities.
+- Updated API key resolution precedence so explicit environment variables (e.g., GEMINI_API_KEY) override stored or broker-migrated static API keys, while deliberate OAuth logins still take highest precedence.
+
+### Fixed
+
+- Improved Vertex AI reliability by automatically falling back to global endpoints on 404 errors.
+- Fixed safety setting application for Google Vertex AI models.
+- Fixed Kimi Code's Anthropic-compatible request path to keep thinking enabled and downgrade forced tool choice for Kimi K2.7 Code title generation.
+- Fixed leaked reasoning fences (such as ```thinking or <think>) across all providers by splitting them into structured thinking blocks during streaming.
+- Fixed Codex requests failing with unsupported all_turns errors on older models (gpt-5.1 and gpt-5.3) by gating the reasoning.context: "all_turns" default to gpt-5.4+ models.
+
+## [16.2.6] - 2026-06-29
+
+### Fixed
+
+- Fixed Antigravity usage reporting to correctly infer daily and weekly quota windows from unlabeled reset-only rows, preventing Cloud Code Assist payloads from collapsing these counters into the default category.
+
 ## [16.2.5] - 2026-06-28
 
 ### Fixed

package/dist/types/auth-storage.d.ts

@@ -650,8 +650,8 @@ export declare 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}.
      */
@@ -778,12 +778,12 @@ export declare class AuthStorage {
     peekApiKey(provider: string): Promise<string | 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)
      */
     getApiKey(provider: string, sessionId?: string, options?: AuthApiKeyOptions): Promise<string | undefined>;
@@ -945,12 +945,13 @@ export declare 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.
      */

package/dist/types/providers/__tests__/kimi-code-thinking.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/providers/google-auth.d.ts

@@ -22,3 +22,11 @@ export declare function getVertexAccessToken(options?: {
 }): Promise<string>;
 /** Test seam: clears every cached token. */
 export declare function __resetVertexTokenCache(): void;
+/**
+ * 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 declare function hasVertexBearerCredentialsHint(): boolean;

package/dist/types/providers/google-interactions.d.ts

@@ -0,0 +1,65 @@
+import type { Context, FetchImpl, Model, ProviderSessionState } from "../types";
+import { AssistantMessageEventStream } from "../utils/event-stream";
+import { type GoogleSharedStreamOptions } from "./google-shared";
+type GoogleInteractionsApi = "google-generative-ai" | "google-vertex";
+/** Provider session state storing the last Gemini Interactions response id. */
+export interface GoogleInteractionsProviderSessionState extends ProviderSessionState {
+    lastInteractionId?: string;
+}
+/** Conversation anchor for continuing an Interactions turn from a prior assistant response. */
+export interface InteractionAnchor {
+    id?: string;
+    messageIndex?: number;
+}
+/** Provider-specific URL, headers, and fetch implementation for an Interactions request. */
+export interface GoogleInteractionsPlan {
+    url: string;
+    headers: Record<string, string>;
+    fetch?: FetchImpl;
+}
+/**
+ * Streams Gemini Interactions API model-mode responses for direct Google and Vertex providers.
+ *
+ * `fallback`, when supplied, is the legacy `:streamGenerateContent` stream factory. It runs
+ * transparently — forwarding its events into this stream — when the Interactions attempt fails
+ * before any content is emitted with a signal that the model/endpoint does not support
+ * Interactions (HTTP 404/400). Provide it only for auto-selected Interactions requests so an
+ * explicit `useInteractionsApi: true` still surfaces failures.
+ */
+export declare function streamGoogleInteractions<T extends GoogleInteractionsApi>(args: {
+    model: Model<T>;
+    context: Context;
+    options: GoogleSharedStreamOptions | undefined;
+    api: T;
+    anchor: InteractionAnchor;
+    state: GoogleInteractionsProviderSessionState | undefined;
+    prepare: () => GoogleInteractionsPlan | Promise<GoogleInteractionsPlan>;
+    fallback?: () => AssistantMessageEventStream;
+}): AssistantMessageEventStream;
+/**
+ * Whether a model is served by the Gemini Interactions API. Interactions is a Gemini 3-era
+ * transport, so the catalog subset that supports it is Gemini 3.0+. Older Gemini and non-Gemini
+ * ids keep `:streamGenerateContent`, which covers the full catalog.
+ */
+export declare function modelSupportsInteractions(model: Pick<Model, "id">): boolean;
+/**
+ * Resolves whether a Google provider call should use Interactions and which lineage anchor to send.
+ *
+ * Precedence: explicit `useInteractionsApi: false` always wins (force generateContent); otherwise
+ * Interactions engages when explicitly requested, when continuing a stored interaction
+ * (`previousInteractionId`/assistant lineage/session state), or when `autoEligible` (the
+ * zero-config default for the capable model subset on the official endpoint). `auto` flags the
+ * last case for the caller — it is the only mode that wires up the generateContent fallback.
+ */
+export declare function resolveInteractionDispatch(args: {
+    context: Context;
+    options: GoogleSharedStreamOptions | undefined;
+    provider: string;
+    autoEligible: boolean;
+}): {
+    useInteractions: boolean;
+    auto: boolean;
+    anchor: InteractionAnchor;
+    state: GoogleInteractionsProviderSessionState | undefined;
+};
+export {};

package/dist/types/providers/google-shared.d.ts

@@ -1,7 +1,7 @@
 /**
  * Shared utilities for Google Generative AI and Google Cloud Code Assist providers.
  */
-import type { AssistantMessage, Context, FetchImpl, Model, StopReason, StreamOptions, TextContent, ThinkingContent, Tool, ToolCall } from "../types";
+import type { AssistantMessage, Context, FetchImpl, Model, ServiceTier, StopReason, StreamOptions, TextContent, ThinkingContent, Tool, ToolCall } from "../types";
 import { AssistantMessageEventStream } from "../utils/event-stream";
 import { normalizeSchemaForGoogle } from "../utils/schema";
 import type { Content, FinishReason, FunctionCallingConfigMode, GenerateContentParameters, GenerateContentResponse, Part } from "./google-types";
@@ -33,6 +33,21 @@ export interface GoogleSharedStreamOptions extends StreamOptions {
         budgetTokens?: number;
         level?: GoogleThinkingLevel;
     };
+    /** Gemini/Vertex serving tier (`flex`/`priority`); other values are omitted. */
+    serviceTier?: ServiceTier;
+    /**
+     * Continues a Gemini Interactions API conversation from a stored interaction.
+     * When set on the direct Google provider, the request uses `/interactions`
+     * with `previous_interaction_id` instead of the legacy generateContent stream.
+     */
+    previousInteractionId?: string;
+    /**
+     * Uses the Gemini Interactions API for direct Google requests, storing the
+     * returned interaction id on the assistant response for follow-up turns.
+     */
+    useInteractionsApi?: boolean;
+    /** Overrides Interactions API request storage; default is the API default (`true`). */
+    storeInteraction?: boolean;
 }
 /**
  * Determines whether a streamed Gemini `Part` should be treated as "thinking".
@@ -60,10 +75,6 @@ export declare function isThinkingPart(part: Pick<Part, "thought" | "thoughtSign
  * a signature from being overwritten with `undefined` within the same streamed block.
  */
 export declare function retainThoughtSignature(existing: string | undefined, incoming: string | undefined): string | undefined;
-/**
- * Claude models via Google APIs require explicit tool call IDs in function calls/responses.
- */
-export declare function requiresToolCallId(modelId: string): boolean;
 /**
  * Convert internal messages to Gemini Content[] format.
  */
@@ -127,6 +138,8 @@ export declare function pushToolCallEvents(toolCall: ToolCall, contentIndex: num
  * `text_start` / `thinking_start` event. `onBeforeStartEvent` lets the SSE consumer
  * inject its `ensureStarted()` first-token side effect into the canonical event order.
  */
+export declare function startTextOrThinkingBlock(isThinking: true, output: AssistantMessage, stream: AssistantMessageEventStream, onBeforeStartEvent?: () => void): ThinkingContent;
+export declare function startTextOrThinkingBlock(isThinking: false, output: AssistantMessage, stream: AssistantMessageEventStream, onBeforeStartEvent?: () => void): TextContent;
 export declare function startTextOrThinkingBlock(isThinking: boolean, output: AssistantMessage, stream: AssistantMessageEventStream, onBeforeStartEvent?: () => void): TextContent | ThinkingContent;
 /**
  * Drives the chunked `generateContentStream` iterator into an `AssistantMessage` and
@@ -178,6 +191,8 @@ export interface GoogleGenAIRequestPlan {
     url: string;
     headers: Record<string, string>;
     fetch?: FetchImpl;
+    /** Optional URL retried once when {@link url} returns 404 (regional Vertex endpoint missing a global-only model). */
+    fallbackUrl?: string;
 }
 export declare function streamGoogleGenAI<T extends "google-generative-ai" | "google-vertex">(args: {
     model: Model<T>;

package/dist/types/providers/google-types.d.ts

@@ -106,6 +106,11 @@ export interface GenerateContentConfig {
     safetySettings?: Array<Record<string, unknown>>;
     cachedContent?: string;
     thinkingConfig?: ThinkingConfig;
+    /**
+     * Gemini/Vertex serving tier. Serialized to the request body root as
+     * `serviceTier` (camelCase) by the transformer in `google-shared.ts`.
+     */
+    serviceTier?: "auto" | "default" | "flex" | "scale" | "priority";
     abortSignal?: AbortSignal;
 }
 /** Top-level argument to `generateContentStream`. */

package/dist/types/providers/openai-codex/request-transformer.d.ts

@@ -9,7 +9,7 @@ export interface ReasoningConfig {
 export interface CodexRequestOptions {
     reasoningEffort?: ReasoningConfig["effort"];
     reasoningSummary?: ReasoningConfig["summary"] | null;
-    /** Explicit `reasoning.context` override; defaults to `all_turns` for every Codex request when unset. */
+    /** Explicit `reasoning.context` override; defaults to `all_turns` when unset. The `all_turns` value is gated to gpt-5.4+ Codex models — older ids reject it, so it is suppressed and `context` omitted. */
     reasoningContext?: CodexReasoningContext;
     textVerbosity?: "low" | "medium" | "high";
     include?: string[];

package/dist/types/providers/openai-codex-responses.d.ts

@@ -4,7 +4,7 @@ import type { ResponseInput } from "./openai-responses-wire";
 export interface OpenAICodexResponsesOptions extends StreamOptions {
     reasoning?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh";
     reasoningSummary?: "auto" | "concise" | "detailed" | null;
-    /** `reasoning.context` replay scope; defaults to `all_turns` for every Codex request when unset. */
+    /** `reasoning.context` replay scope; defaults to `all_turns` when unset. The `all_turns` value is gated to gpt-5.4+ Codex models — older ids reject it, so it is suppressed and `context` omitted. */
     reasoningContext?: CodexReasoningContext;
     textVerbosity?: "low" | "medium" | "high";
     include?: string[];

package/dist/types/providers/openai-shared.d.ts

@@ -1,5 +1,5 @@
 import type { OpenAICompat, OpenAIReasoningDisableMode, OpenAIStreamMarkupHealingPattern, OpenRouterRouting, ResolvedOpenAICompat, ResolvedOpenAIResponsesCompat, ResolvedOpenAISharedCompat, VercelGatewayRouting } from "@oh-my-pi/pi-catalog/types";
-import { type Api, type AssistantMessage, type CacheRetention, type Context, type ImageContent, type Message, type MessageAttribution, type Model, type Provider, type ResolvedServiceTier, type ServiceTier, type StopReason, type StreamOptions, type TextContent, type TextSignatureV1, type ThinkingContent, type Tool, type ToolCall, type ToolResultMessage } from "../types";
+import { type Api, type AssistantMessage, type CacheRetention, type Context, type ImageContent, type Message, type MessageAttribution, type Model, type Provider, type ServiceTier, type StopReason, type StreamOptions, type TextContent, type TextSignatureV1, type ThinkingContent, type Tool, type ToolCall, type ToolResultMessage } from "../types";
 import { kStreamingLastParseLen, kStreamingPartialJson } from "../utils/block-symbols";
 import type { AssistantMessageEventStream } from "../utils/event-stream";
 import type { CapturedHttpErrorResponse } from "../utils/http-inspector";
@@ -55,7 +55,7 @@ export interface OpenAIRequestSetup {
 }
 export declare function resolveOpenAIRequestSetup(model: OpenAIRequestSetupModel, options: OpenAIRequestSetupOptions): OpenAIRequestSetup;
 export declare function applyOpenAIServiceTier(params: {
-    service_tier?: ResolvedServiceTier | "auto" | "default" | null | undefined;
+    service_tier?: ServiceTier | null | undefined;
 }, serviceTier: ServiceTier | null | undefined, provider: Provider | undefined): void;
 /**
  * Adjust resolved cost by the service tier OpenAI actually billed — parity with
@@ -207,7 +207,7 @@ export type OpenAICompletionsParams = Omit<ChatCompletionCreateParamsStreaming,
         enabled: false;
     };
     reasoning_effort?: string | null;
-    service_tier?: ResolvedServiceTier;
+    service_tier?: ServiceTier;
     tool_stream?: boolean;
     provider?: OpenAICompat["openRouterRouting"];
     providerOptions?: {

package/dist/types/types.d.ts

@@ -73,48 +73,82 @@ export type ToolChoice = "auto" | "none" | "any" | "required" | {
 };
 export type CacheRetention = "none" | "short" | "long";
 /**
- * Service tier hint for processing priority / cost control.
+ * Service tier hint for processing priority / cost control. These are the
+ * values providers consume on the wire:
  *
- * The unscoped values (`"auto"`, `"default"`, `"flex"`, `"scale"`,
- * `"priority"`) are passed through to providers that understand them
- * (OpenAI's `service_tier` field directly; Anthropic translates
- * `"priority"` into `speed: "fast"` on supported Opus models).
+ * - OpenAI / OpenAI-Codex: sent verbatim as the `service_tier` field
+ *   (`flex`/`scale`/`priority`).
+ * - Google (Gemini API + Vertex AI): sent as the top-level `serviceTier`
+ *   field (`flex`/`priority`).
+ * - OpenRouter: passed through as `service_tier`; OpenRouter realizes it for
+ *   the OpenAI- and Google-family upstreams it supports and ignores it
+ *   otherwise.
+ * - Direct Anthropic: `"priority"` is translated into `speed: "fast"` plus the
+ *   fast-mode beta on supported Opus models. Other tiers are ignored.
  *
- * The scoped values target a specific provider family and behave as the
- * unscoped value on the matching provider, or `undefined` everywhere else.
- * They let users opt into priority on one family without paying premium
- * costs on the other when switching models mid-session.
+ * Per-family scoping is expressed by {@link ServiceTierByFamily}, not by
+ * scoped sentinel values — see {@link serviceTierFamily}.
+ */
+export type ServiceTier = "auto" | "default" | "flex" | "scale" | "priority";
+/** Provider families that expose an independent service-tier knob. */
+export type ServiceTierFamily = "openai" | "anthropic" | "google";
+/**
+ * Per-family service-tier selection. A request consults only the entry for the
+ * family its model belongs to (see {@link resolveModelServiceTier}), so a user
+ * can opt one family into priority without affecting the others when switching
+ * models mid-session.
+ */
+export type ServiceTierByFamily = Partial<Record<ServiceTierFamily, ServiceTier>>;
+/**
+ * Classify a model into the service-tier family whose knob governs it, or
+ * `undefined` when the model exposes no serving-priority control.
  *
- * - `"openai-only"` → `"priority"` on `openai` and `openai-codex`; ignored elsewhere.
- * - `"claude-only"` → `"priority"` on direct `anthropic` (not Bedrock/Vertex Claude).
+ * OpenRouter models are classified by id namespace (`anthropic/`, `google/`,
+ * `openai/`); Claude on Bedrock/Vertex (api `anthropic-messages`) is the
+ * anthropic family even though its provider is `amazon-bedrock`/`google-vertex`.
  */
-export type ServiceTier = "auto" | "default" | "flex" | "scale" | "priority" | "openai-only" | "claude-only";
-/** Resolved tier — one of the values that providers actually consume on the wire. */
-export type ResolvedServiceTier = Exclude<ServiceTier, "openai-only" | "claude-only">;
+export declare function serviceTierFamily(model: Pick<Model, "provider" | "api" | "id">): ServiceTierFamily | undefined;
 /**
- * Resolves a possibly scoped `ServiceTier` to the effective tier for the
- * given provider. Scoped values match their target family and otherwise
- * collapse to `undefined`; unscoped values pass through unchanged.
+ * Reduce a per-family tier map to the single wire tier for `model` — the entry
+ * for the model's family, or `undefined` when the model has no family.
  */
-export declare function resolveServiceTier(serviceTier: ServiceTier | null | undefined, provider: Provider | undefined): ResolvedServiceTier | undefined;
+export declare function resolveModelServiceTier(tiers: ServiceTierByFamily | null | undefined, model: Pick<Model, "provider" | "api" | "id">): ServiceTier | undefined;
 /**
- * True when the (possibly scoped) tier should be sent on the wire as the
- * `service_tier` request field for the given provider. OpenAI / OpenAI-Codex
- * accept `flex`/`scale`/`priority`; Fireworks Serverless realizes only its
- * Priority serving path (`service_tier: "priority"`) on the OpenAI-compatible
- * chat-completions endpoint. Unsupported tiers (`"auto"`, `"default"`), other
- * providers, and scope mismatches all return false.
+ * True when the tier should be sent on the wire as the provider's service-tier
+ * request field. OpenAI / OpenAI-Codex accept `flex`/`scale`/`priority`; Google
+ * (Gemini API + Vertex) and OpenRouter accept `flex`/`priority`; Fireworks
+ * Serverless realizes only its Priority serving path. Anthropic is absent — it
+ * realizes `priority` via `speed: "fast"`, not a service-tier field.
  */
 export declare function shouldSendServiceTier(serviceTier: ServiceTier | null | undefined, provider: Provider | undefined): boolean;
 /**
- * Premium-request weight contributed by sending priority to a provider
- * that supports it. Mirrors GitHub Copilot's `premiumRequests` accounting
- * so the "premium requests" stat aggregates priority traffic across the
- * OpenAI family and Anthropic fast-mode realizations.
+ * True when `priority` will actually be realized on the wire for `model`.
+ * Direct Anthropic realizes fast mode; OpenAI/Google/Fireworks emit the
+ * service-tier field; OpenRouter realizes it only for its OpenAI- and
+ * Google-family upstreams. Bedrock/Vertex Claude and OpenRouter Anthropic
+ * models do not realize priority and return `false`.
+ */
+export declare function realizesPriorityServiceTier(serviceTier: ServiceTier | null | undefined, model: Pick<Model, "provider" | "api" | "id">): boolean;
+/**
+ * Premium-request weight contributed by a priority request to a provider that
+ * realizes it and bills extra. Mirrors GitHub Copilot's `premiumRequests`
+ * accounting so the "premium requests" stat aggregates priority traffic across
+ * the OpenAI family, direct Anthropic fast mode, and Google priority.
  *
- * Returns 1 per resolved priority request, 0 otherwise.
+ * Returns 1 only when priority is actually realized on the wire for `model`
+ * (see {@link realizesPriorityServiceTier}) and the provider bills it as a
+ * premium request. OpenRouter is excluded — it bills per its own pricing, not
+ * Copilot-premium semantics — as are Bedrock/Vertex Claude, where priority is
+ * silently dropped.
+ */
+export declare function getPriorityPremiumRequests(serviceTier: ServiceTier | null | undefined, model: Pick<Model, "provider" | "api" | "id">): number;
+/**
+ * Coerce a persisted service-tier value to a {@link ServiceTierByFamily}. Newer
+ * sessions store the family map directly; legacy sessions stored a single
+ * scalar — `"priority"` applied everywhere, `"openai-only"`/`"claude-only"`
+ * scoped to one family, and the remaining values were OpenAI-only semantics.
  */
-export declare function getPriorityPremiumRequests(serviceTier: ServiceTier | null | undefined, provider: Provider | undefined): number;
+export declare function coerceServiceTierByFamily(value: unknown): ServiceTierByFamily | undefined;
 export interface ProviderSessionState {
     close(): void;
 }
@@ -204,6 +238,22 @@ export interface StreamOptions {
      * Providers can use this to persist transport/session state between turns.
      */
     providerSessionState?: Map<string, ProviderSessionState>;
+    /**
+     * Force Gemini model-mode Interactions API transport for providers that support it.
+     * When unset, those providers may still use Interactions to continue known
+     * server-side conversation lineage via `previousInteractionId` or stored state.
+     */
+    useInteractionsApi?: boolean;
+    /**
+     * Whether supported Interactions transports should store server-side conversation
+     * state and return response ids for follow-up turns. Defaults to true.
+     */
+    storeInteraction?: boolean;
+    /**
+     * Explicit Interactions response id to continue. Mutually exclusive with
+     * `storeInteraction: false` because the follow-up itself must be storable.
+     */
+    previousInteractionId?: string;
     /**
      * Optional per-provider concurrent request cap for LLM stream calls. Keys are
      * provider ids (`model.provider`); positive numeric values cap in-flight

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

@@ -0,0 +1,29 @@
+/**
+ * Central live healing for leaked reasoning markup in the visible text channel.
+ *
+ * Some providers emit their canonical reasoning idioms (` ```thinking `,
+ * `<think>`, Gemma/Harmony channels, …) into the *visible* text stream instead
+ * of a structured thinking part. {@link wrapLeakedThinkingStream} re-projects any
+ * provider stream into a fresh {@link AssistantMessageEventStream}, splitting the
+ * leaked fences out into proper `thinking` blocks *live* as deltas arrive — so
+ * every provider gets the same healing, not just the three with provider-local
+ * {@link StreamMarkupHealing} loops.
+ *
+ * The healing is idempotent: a second pass over already-clean text finds no
+ * fences, so wrapping a provider that already heals (or wrapping twice) is a
+ * harmless pass-through. Signatures are load-bearing for Google/Gemini/Vertex
+ * thought round-tripping, so text sub-blocks carry the source `textSignature`,
+ * forwarded thinking blocks their `thinkingSignature`, and forwarded tool calls
+ * their `thoughtSignature`.
+ *
+ * Modeled on {@link wrapInbandToolStream} / `InbandStreamProjector` in
+ * `../dialect/owned-stream.ts`, minus all in-band tool-call grammar: tool-call
+ * events are forwarded verbatim.
+ */
+import { AssistantMessageEventStream } from "./event-stream";
+/**
+ * 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
+ * inner one; the inner stream is fully consumed.
+ */
+export declare function wrapLeakedThinkingStream(inner: AssistantMessageEventStream): AssistantMessageEventStream;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "16.2.5",
+	"version": "16.2.7",
 	"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.2.5",
-		"@oh-my-pi/pi-utils": "16.2.5",
-		"@oh-my-pi/pi-wire": "16.2.5",
+		"@oh-my-pi/pi-catalog": "16.2.7",
+		"@oh-my-pi/pi-utils": "16.2.7",
+		"@oh-my-pi/pi-wire": "16.2.7",
 		"arktype": "^2.2.0",
 		"zod": "^4"
 	},