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

package/src/stream.ts

@@ -71,6 +71,7 @@ import type {
 	ToolChoice,
 } from "./types";
 import { AssistantMessageEventStream } from "./utils/event-stream";
+import { wrapLeakedThinkingStream } from "./utils/leaked-thinking-stream";
 import { wrapFetchForProxy } from "./utils/proxy";
 import { withRequestDebugFetch } from "./utils/request-debug";
 import { withGeminiThinkingLoopGuard } from "./utils/thinking-loop";
@@ -499,8 +500,11 @@ function withProviderInFlightLimit<TOptions extends Pick<StreamOptions, "signal"
 	options: TOptions | undefined,
 	dispatch: () => AssistantMessageEventStream,
 ): AssistantMessageEventStream {
+	// Leaked-thinking healing folds in here — the one shared provider-dispatch
+	// chokepoint — so the loop guard (which wraps this) sees healed events and all
+	// six provider exits are covered by one wrap. Healing is idempotent.
 	const limit = resolveProviderInFlightLimit(model.provider, options);
-	if (limit === undefined) return dispatch();
+	if (limit === undefined) return wrapLeakedThinkingStream(dispatch());
 
 	const outer = new AssistantMessageEventStream();
 	void (async () => {
@@ -520,7 +524,7 @@ function withProviderInFlightLimit<TOptions extends Pick<StreamOptions, "signal"
 			if (options?.signal?.aborted) {
 				throw options.signal.reason ?? new AIError.AbortError("Provider request aborted before dispatch");
 			}
-			const inner = dispatch();
+			const inner = wrapLeakedThinkingStream(dispatch());
 			try {
 				for await (const event of inner) {
 					outer.push(event);
@@ -1105,10 +1109,13 @@ export function streamSimple<TApi extends Api>(
 
 	// GitLab Duo Workflow - IDE workflow protocol + WebSocket action bridge
 	if (model.api === "gitlab-duo-agent") {
-		return streamGitLabDuoWorkflow(model as Model<"gitlab-duo-agent">, context, {
-			...requestOptions,
-			apiKey,
-		});
+		// Does not route through withProviderInFlightLimit, so heal explicitly.
+		return wrapLeakedThinkingStream(
+			streamGitLabDuoWorkflow(model as Model<"gitlab-duo-agent">, context, {
+				...requestOptions,
+				apiKey,
+			}),
+		);
 	}
 
 	// Kimi Code - route to dedicated handler that wraps OpenAI or Anthropic API
@@ -1355,6 +1362,9 @@ function mapOptionsForApi<TApi extends Api>(
 		streamFirstEventTimeoutMs: options?.streamFirstEventTimeoutMs,
 		streamIdleTimeoutMs: options?.streamIdleTimeoutMs,
 		providerSessionState: options?.providerSessionState,
+		useInteractionsApi: options?.useInteractionsApi,
+		storeInteraction: options?.storeInteraction,
+		previousInteractionId: options?.previousInteractionId,
 		maxInFlightRequests: options?.maxInFlightRequests,
 		onPayload: options?.onPayload,
 		onResponse: options?.onResponse,
@@ -1565,6 +1575,7 @@ function mapOptionsForApi<TApi extends Api>(
 			if (!reasoning || !model.reasoning) {
 				return castApi<"google-generative-ai">({
 					...base,
+					serviceTier: options?.serviceTier,
 					thinking: { enabled: false },
 					toolChoice: mapGoogleToolChoice(options?.toolChoice),
 				});
@@ -1578,6 +1589,7 @@ function mapOptionsForApi<TApi extends Api>(
 			if (googleModel.thinking?.mode === "google-level") {
 				return castApi<"google-generative-ai">({
 					...base,
+					serviceTier: options?.serviceTier,
 					thinking: {
 						enabled: true,
 						level: mapEffortToGoogleThinkingLevel(effort),
@@ -1661,6 +1673,7 @@ function mapOptionsForApi<TApi extends Api>(
 			if (!reasoning || !model.reasoning) {
 				return castApi<"google-vertex">({
 					...base,
+					serviceTier: options?.serviceTier,
 					thinking: { enabled: false },
 					toolChoice: mapGoogleToolChoice(options?.toolChoice),
 				});
@@ -1673,6 +1686,7 @@ function mapOptionsForApi<TApi extends Api>(
 			if (geminiModel.thinking?.mode === "google-level") {
 				return castApi<"google-vertex">({
 					...base,
+					serviceTier: options?.serviceTier,
 					thinking: {
 						enabled: true,
 						level: mapEffortToGoogleThinkingLevel(effort),
@@ -1683,6 +1697,7 @@ function mapOptionsForApi<TApi extends Api>(
 
 			return castApi<"google-vertex">({
 				...base,
+				serviceTier: options?.serviceTier,
 				thinking: {
 					enabled: true,
 					budgetTokens: getGoogleBudget(geminiModel, effort, options?.thinkingBudgets),

package/src/types.ts

@@ -105,84 +105,181 @@ export type ToolChoice =
 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.
- *
- * - `"openai-only"` → `"priority"` on `openai` and `openai-codex`; ignored elsewhere.
- * - `"claude-only"` → `"priority"` on direct `anthropic` (not Bedrock/Vertex Claude).
+ * Per-family scoping is expressed by {@link ServiceTierByFamily}, not by
+ * scoped sentinel values — see {@link serviceTierFamily}.
  */
-export type ServiceTier = "auto" | "default" | "flex" | "scale" | "priority" | "openai-only" | "claude-only";
+export type ServiceTier = "auto" | "default" | "flex" | "scale" | "priority";
 
-/** Resolved tier — one of the values that providers actually consume on the wire. */
-export type ResolvedServiceTier = Exclude<ServiceTier, "openai-only" | "claude-only">;
+/** Provider families that expose an independent service-tier knob. */
+export type ServiceTierFamily = "openai" | "anthropic" | "google";
 
 /**
- * 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.
+ * 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 function resolveServiceTier(
-	serviceTier: ServiceTier | null | undefined,
-	provider: Provider | undefined,
-): ResolvedServiceTier | undefined {
-	if (!serviceTier) return undefined;
-	switch (serviceTier) {
-		case "openai-only":
-			return provider === "openai" || provider === "openai-codex" ? "priority" : undefined;
-		case "claude-only":
-			return provider === "anthropic" ? "priority" : undefined;
-		default:
-			return serviceTier;
+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.
+ *
+ * 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 function serviceTierFamily(model: Pick<Model, "provider" | "api" | "id">): ServiceTierFamily | undefined {
+	const provider = model.provider;
+	if (provider === "openrouter") {
+		const id = model.id.toLowerCase();
+		if (id.startsWith("anthropic/")) return "anthropic";
+		if (id.startsWith("google/")) return "google";
+		if (id.startsWith("openai/")) return "openai";
+		return undefined;
 	}
+	if (provider === "openai" || provider === "openai-codex") return "openai";
+	if (model.api === "anthropic-messages") return "anthropic";
+	if (provider === "google" || provider === "google-vertex") return "google";
+	return 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.
+ * 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 function resolveModelServiceTier(
+	tiers: ServiceTierByFamily | null | undefined,
+	model: Pick<Model, "provider" | "api" | "id">,
+): ServiceTier | undefined {
+	if (!tiers) return undefined;
+	const family = serviceTierFamily(model);
+	return family ? tiers[family] : undefined;
+}
+
+/**
+ * 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 function shouldSendServiceTier(
 	serviceTier: ServiceTier | null | undefined,
 	provider: Provider | undefined,
 ): boolean {
-	const resolved = resolveServiceTier(serviceTier, provider);
-	if (provider === "openai" || provider === "openai-codex") {
-		return resolved === "flex" || resolved === "scale" || resolved === "priority";
+	if (!serviceTier) return false;
+	if (provider === "openai" || provider === "openai-codex" || provider === "openrouter") {
+		return serviceTier === "flex" || serviceTier === "scale" || serviceTier === "priority";
+	}
+	if (provider === "google") {
+		return serviceTier === "flex" || serviceTier === "priority";
 	}
-	if (provider === "fireworks") {
-		return resolved === "priority";
+	// Vertex realizes only priority (via header); flex has no documented control.
+	if (provider === "google-vertex" || provider === "fireworks") {
+		return serviceTier === "priority";
 	}
 	return false;
 }
 
 /**
- * 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 function realizesPriorityServiceTier(
+	serviceTier: ServiceTier | null | undefined,
+	model: Pick<Model, "provider" | "api" | "id">,
+): boolean {
+	if (serviceTier !== "priority") return false;
+	if (model.provider === "anthropic") return true;
+	if (model.provider === "openrouter") {
+		const family = serviceTierFamily(model);
+		return family === "openai" || family === "google";
+	}
+	if (model.api === "anthropic-messages") return false;
+	return shouldSendServiceTier(serviceTier, model.provider);
+}
+
+/**
+ * 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 function getPriorityPremiumRequests(
 	serviceTier: ServiceTier | null | undefined,
-	provider: Provider | undefined,
+	model: Pick<Model, "provider" | "api" | "id">,
 ): number {
-	if (resolveServiceTier(serviceTier, provider) !== "priority") return 0;
-	// Only providers that realize `priority` on the wire bill the user.
-	// Everywhere else, the field is silently dropped and nothing is charged.
-	return provider === "openai" || provider === "openai-codex" || provider === "anthropic" ? 1 : 0;
+	if (!realizesPriorityServiceTier(serviceTier, model)) return 0;
+	const provider = model.provider;
+	return provider === "openai" ||
+		provider === "openai-codex" ||
+		provider === "anthropic" ||
+		provider === "google" ||
+		provider === "google-vertex"
+		? 1
+		: 0;
+}
+
+/**
+ * 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 function coerceServiceTierByFamily(value: unknown): ServiceTierByFamily | undefined {
+	if (value === null || value === undefined) return undefined;
+	if (typeof value === "object") {
+		const src = value as Record<string, unknown>;
+		const out: ServiceTierByFamily = {};
+		for (const family of ["openai", "anthropic", "google"] as const) {
+			const tier = src[family];
+			if (tier === "auto" || tier === "default" || tier === "flex" || tier === "scale" || tier === "priority") {
+				out[family] = tier;
+			}
+		}
+		return Object.keys(out).length > 0 ? out : undefined;
+	}
+	switch (value) {
+		case "priority":
+			return { openai: "priority", anthropic: "priority", google: "priority" };
+		case "openai-only":
+			return { openai: "priority" };
+		case "claude-only":
+			return { anthropic: "priority" };
+		case "auto":
+			return { openai: "auto" };
+		case "default":
+			return { openai: "default" };
+		case "flex":
+			return { openai: "flex" };
+		case "scale":
+			return { openai: "scale" };
+		default:
+			return undefined;
+	}
 }
 
 export interface ProviderSessionState {
@@ -277,6 +374,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/src/utils/leaked-thinking-stream.ts

@@ -0,0 +1,260 @@
+/**
+ * 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 type { AssistantMessage, TextContent, ThinkingContent, ToolCall } from "../types";
+import { AssistantMessageEventStream } from "./event-stream";
+import { StreamMarkupHealing, type StreamMarkupHealingEvent } from "./stream-markup-healing";
+
+/**
+ * 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 function wrapLeakedThinkingStream(inner: AssistantMessageEventStream): AssistantMessageEventStream {
+	const out = new AssistantMessageEventStream();
+	void (async () => {
+		try {
+			let projector: LeakedThinkingProjector | undefined;
+			for await (const event of inner) {
+				switch (event.type) {
+					case "start":
+						projector = new LeakedThinkingProjector(out, event.partial);
+						break;
+					case "text_delta": {
+						projector ??= new LeakedThinkingProjector(out, event.partial);
+						const block = event.partial.content[event.contentIndex];
+						projector.text(event.delta, block?.type === "text" ? block.textSignature : undefined);
+						break;
+					}
+					case "thinking_delta": {
+						projector ??= new LeakedThinkingProjector(out, event.partial);
+						const block = event.partial.content[event.contentIndex];
+						projector.thinking(event.delta, block?.type === "thinking" ? block.thinkingSignature : undefined);
+						break;
+					}
+					case "toolcall_start": {
+						projector ??= new LeakedThinkingProjector(out, event.partial);
+						const block = event.partial.content[event.contentIndex];
+						projector.toolStart(event.contentIndex, block?.type === "toolCall" ? block.name : "");
+						break;
+					}
+					case "toolcall_delta":
+						projector?.toolDelta(event.contentIndex, event.delta);
+						break;
+					case "toolcall_end":
+						projector?.toolEnd(event.contentIndex, event.toolCall);
+						break;
+					case "done": {
+						projector ??= new LeakedThinkingProjector(out, event.message);
+						const content = projector.finish(event.message);
+						out.push({ type: "done", reason: event.reason, message: { ...event.message, content } });
+						return;
+					}
+					case "error": {
+						projector ??= new LeakedThinkingProjector(out, event.error);
+						const content = projector.finish(event.error);
+						out.push({ type: "error", reason: event.reason, error: { ...event.error, content } });
+						return;
+					}
+					// text_start/text_end/thinking_start/thinking_end are ignored: the
+					// projector owns block boundaries (matches wrapInbandToolStream).
+				}
+			}
+			// Inner ended via end(result) without a terminal event.
+			if (!out.done) {
+				const result = await inner.result();
+				projector ??= new LeakedThinkingProjector(out, result);
+				const content = projector.finish(result);
+				out.end({ ...result, content });
+			}
+		} catch (err) {
+			if (!out.done) out.fail(err);
+		}
+	})();
+	return out;
+}
+
+type OpenBlock = { index: number } | undefined;
+
+/**
+ * Re-projects an inner stream's events into `out`, healing leaked reasoning out
+ * of the visible text channel while forwarding native thinking and tool calls.
+ */
+class LeakedThinkingProjector {
+	readonly #out: AssistantMessageEventStream;
+	readonly #healer = new StreamMarkupHealing({ pattern: "thinking" });
+	#partial: AssistantMessage;
+	#text: OpenBlock;
+	#thinking: OpenBlock;
+	/** Total visible text length fed to the healer, to replay any un-streamed tail in {@link finish}. */
+	#fedLen = 0;
+	/** Latest non-undefined text signature seen, stamped onto held-back text flushed later. */
+	#lastTextSignature: string | undefined;
+	/** Forwarded native tool calls, keyed by the inner stream's `contentIndex`. */
+	#toolBlocks = new Map<number, { index: number }>();
+
+	constructor(out: AssistantMessageEventStream, seed: AssistantMessage) {
+		this.#out = out;
+		this.#partial = { ...seed, content: [] };
+		this.#out.push({ type: "start", partial: this.#partial });
+	}
+
+	/** Feed a visible-text delta through the healer, splitting leaked fences live. */
+	text(delta: string, signature: string | undefined): void {
+		this.#fedLen += delta.length;
+		if (signature !== undefined) this.#lastTextSignature = signature;
+		this.#apply(this.#healer.feedEvents(delta), this.#lastTextSignature);
+	}
+
+	/** Forward a native thinking delta, preserving its signature. */
+	thinking(delta: string, signature: string | undefined): void {
+		const index = this.#openThinking();
+		const block = this.#partial.content[index] as ThinkingContent;
+		block.thinking += delta;
+		if (signature !== undefined) block.thinkingSignature = signature;
+		this.#out.push({ type: "thinking_delta", contentIndex: index, delta, partial: this.#partial });
+	}
+
+	/** Forward a native tool call's start, releasing any held-back text first. */
+	toolStart(srcIndex: number, name: string): void {
+		this.#apply(this.#healer.flushEvents(), this.#lastTextSignature);
+		this.#closeText();
+		this.#closeThinking();
+		const block: ToolCall = { type: "toolCall", id: "", name, arguments: {} };
+		this.#partial.content.push(block);
+		const index = this.#partial.content.length - 1;
+		this.#toolBlocks.set(srcIndex, { index });
+		this.#out.push({ type: "toolcall_start", contentIndex: index, partial: this.#partial });
+	}
+
+	toolDelta(srcIndex: number, delta: string): void {
+		const entry = this.#toolBlocks.get(srcIndex);
+		if (!entry) return;
+		this.#out.push({ type: "toolcall_delta", contentIndex: entry.index, delta, partial: this.#partial });
+	}
+
+	toolEnd(srcIndex: number, toolCall: ToolCall): void {
+		const entry = this.#toolBlocks.get(srcIndex);
+		if (entry) {
+			const block = this.#partial.content[entry.index] as ToolCall;
+			Object.assign(block, toolCall);
+			this.#out.push({ type: "toolcall_end", contentIndex: entry.index, toolCall: block, partial: this.#partial });
+			this.#toolBlocks.delete(srcIndex);
+			return;
+		}
+		// `end` without a matching `start` — release held text, then forward whole.
+		this.#apply(this.#healer.flushEvents(), this.#lastTextSignature);
+		this.#closeText();
+		this.#closeThinking();
+		const block: ToolCall = { ...toolCall };
+		this.#partial.content.push(block);
+		const index = this.#partial.content.length - 1;
+		this.#out.push({ type: "toolcall_start", contentIndex: index, partial: this.#partial });
+		this.#out.push({ type: "toolcall_end", contentIndex: index, toolCall: block, partial: this.#partial });
+	}
+
+	/**
+	 * Finalize: replay any un-streamed visible-text tail from `message.content`,
+	 * flush held-back fragments, close open blocks, and return the healed content.
+	 */
+	finish(message: AssistantMessage): AssistantMessage["content"] {
+		let fullText = "";
+		let tailSignature: string | undefined;
+		for (const block of message.content) {
+			if (block.type === "text") {
+				fullText += block.text;
+				tailSignature = block.textSignature;
+			}
+		}
+		if (tailSignature !== undefined) this.#lastTextSignature = tailSignature;
+		if (fullText.length > this.#fedLen) {
+			this.#apply(this.#healer.feedEvents(fullText.slice(this.#fedLen)), this.#lastTextSignature);
+		}
+		this.#apply(this.#healer.flushEvents(), this.#lastTextSignature);
+		this.#closeText();
+		this.#closeThinking();
+		return this.#partial.content;
+	}
+
+	#apply(events: readonly StreamMarkupHealingEvent[], signature?: string): void {
+		for (const event of events) {
+			if (event.type === "text") this.#emitText(event.text, signature);
+			else if (event.type === "thinking") this.#emitHealedThinking(event.thinking);
+		}
+	}
+
+	#emitText(text: string, signature: string | undefined): void {
+		if (text.length === 0) return;
+		this.#closeThinking();
+		if (!this.#text) {
+			const block: TextContent =
+				signature === undefined ? { type: "text", text: "" } : { type: "text", text: "", textSignature: signature };
+			this.#partial.content.push(block);
+			this.#text = { index: this.#partial.content.length - 1 };
+			this.#out.push({ type: "text_start", contentIndex: this.#text.index, partial: this.#partial });
+		} else if (signature !== undefined) {
+			(this.#partial.content[this.#text.index] as TextContent).textSignature = signature;
+		}
+		const block = this.#partial.content[this.#text.index] as TextContent;
+		block.text += text;
+		this.#out.push({ type: "text_delta", contentIndex: this.#text.index, delta: text, partial: this.#partial });
+	}
+
+	/** Healed (leaked) thinking carries no signature, matching the source fence. */
+	#emitHealedThinking(text: string): void {
+		if (text.length === 0) return;
+		const index = this.#openThinking();
+		const block = this.#partial.content[index] as ThinkingContent;
+		block.thinking += text;
+		this.#out.push({ type: "thinking_delta", contentIndex: index, delta: text, partial: this.#partial });
+	}
+
+	#openThinking(): number {
+		this.#closeText();
+		if (!this.#thinking) {
+			this.#partial.content.push({ type: "thinking", thinking: "" });
+			this.#thinking = { index: this.#partial.content.length - 1 };
+			this.#out.push({ type: "thinking_start", contentIndex: this.#thinking.index, partial: this.#partial });
+		}
+		return this.#thinking.index;
+	}
+
+	#closeText(): void {
+		if (!this.#text) return;
+		const block = this.#partial.content[this.#text.index] as TextContent;
+		this.#out.push({ type: "text_end", contentIndex: this.#text.index, content: block.text, partial: this.#partial });
+		this.#text = undefined;
+	}
+
+	#closeThinking(): void {
+		if (!this.#thinking) return;
+		const block = this.#partial.content[this.#thinking.index] as ThinkingContent;
+		this.#out.push({
+			type: "thinking_end",
+			contentIndex: this.#thinking.index,
+			content: block.thinking,
+			partial: this.#partial,
+		});
+		this.#thinking = undefined;
+	}
+}