@oh-my-pi/pi-ai 17.2.4 → 17.2.5

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## [Unreleased]
 
+## [17.2.5] - 2026-08-03
+
+### Changed
+
+- Standardized tool-call examples in `renderToolExamples` and `renderToolInventory` to use Python keyword-argument syntax (`name(key="value")`) across all models, removing the model-specific dialect parameter and the `DialectRenderOptions.example` flag.
+- Updated `renderToolInventory` to render the tool catalog as a unified OpenAI-Harmony-style `## functions` block using TypeScript type declarations and comments, replacing the previous per-tool Markdown sections.
+- Added a `style: "harmony"` option to `jsonSchemaToTypeScript` for generating compact, comma-delimited TypeScript definitions.
+
+### Fixed
+
+- Fixed a session-blocking issue where unescaped Harmony control tokens in replayed assistant responses and tool inputs caused subsequent requests to be rejected with `invalid_prompt` errors.
+- Fixed an issue where Codex Responses dropped native image-generation results from assistant content and replays due to stale `generating` statuses.
+- Fixed Anthropic stream truncation handling where unexpected connection closures were incorrectly treated as clean stops, causing the agent loop to halt silently mid-sentence.
+- Optimized Anthropic prompt caching to prevent unnecessary cache invalidation of the entire system prefix when volatile project footer details (such as current working directory, date, or workspace tree) change.
+
 ## [17.2.4] - 2026-08-01
 
 ### Fixed

package/dist/types/dialect/examples.d.ts

@@ -1,2 +1,10 @@
-import type { Dialect, InbandTool } from "./types.js";
-export declare function renderToolExamples(tool: InbandTool, dialect: Dialect, intentField?: string): string;
+import type { InbandTool } from "./types.js";
+/**
+ * Render a tool's examples as an `<examples>` block. Calls render in Python
+ * keyword-argument syntax (`name(key="value", n=1)`) regardless of the model's
+ * tool-call dialect, so example bytes stay identical across models. Multiline
+ * string args render as verbatim `"""…"""` blocks, and a call whose only
+ * argument is a string renders as the bare value — the block already names the
+ * tool, and payload args (commands, code, patches) read best verbatim.
+ */
+export declare function renderToolExamples(tool: InbandTool, intentField?: string): string;

package/dist/types/dialect/inventory.d.ts

@@ -1,12 +1,9 @@
 import type { InbandTool } from "./types.js";
 /**
- * Human-readable per-tool inventory: each tool renders as a `# Tool: <name>`
- * section with its description, a simplified TypeScript-style parameter
- * signature (derived from the wire JSON Schema), and examples in the model's
- * native dialect. Shared by the verbose system-prompt inventory and
- * `/dump` so both render the catalog the same way.
- *
- * `model` is a model id; the native example dialect is resolved from it
- * (`preferredDialect`, which falls back to XML for empty/unknown ids).
+ * Tool catalog in the OpenAI-Harmony `namespace functions { … }` shape: each
+ * tool renders as its full description (and Python-syntax examples) as `//`
+ * comment lines above a flat `type <name> = (_: {…});` declaration. Shared by
+ * the verbose system-prompt inventory and `/dump` so both render the catalog
+ * the same way.
  */
-export declare function renderToolInventory(tools: readonly InbandTool[], model: string): string;
+export declare function renderToolInventory(tools: readonly InbandTool[]): string;

package/dist/types/dialect/rendering.d.ts

@@ -4,6 +4,15 @@ export declare function renderToolResponseResults(results: readonly DialectToolR
 export declare function kimiCallId(name: string, id: string, index: number): string;
 export declare function harmonyRecipient(name: string): string;
 export declare function stringifyJson(value: unknown): string;
+/**
+ * Render `name(key=value, …)` with Python-literal argument values. Top-level
+ * multiline strings render as verbatim `"""…"""` blocks so payload-carrying
+ * args (file content, scripts, patches) keep real newlines instead of `\n`
+ * escape soup; nested values always use escaped single-line literals.
+ */
+export declare function pyCall(name: string, args: Record<string, unknown>): string;
+/** Render a JSON-ish value as a Python literal (`True`/`False`/`None`, escaped strings, lists, dicts). */
+export declare function pyValue(value: unknown): string;
 export declare function escapeXmlAttr(value: string): string;
 export declare function escapeXmlText(value: string): string;
 export type AssistantTranscriptParts = {

package/dist/types/dialect/types.d.ts

@@ -42,7 +42,6 @@ export interface DialectToolResult {
 }
 export interface DialectRenderOptions {
     readonly tools?: readonly InbandTool[];
-    readonly example?: boolean;
 }
 export interface DialectDefinition {
     readonly dialect: CatalogDialect;

package/dist/types/error/flags.d.ts

@@ -40,6 +40,11 @@ export declare function retriable(id: number | undefined, opts?: {
 }): boolean;
 export declare function status(error: unknown): number | undefined;
 export declare function isStreamReadErrorText(text: string): boolean;
+/** Persisted-text form of {@link isStreamEnvelopeError}: recognizes the
+ *  prefix-tagged envelope diagnostic on an aborted turn's `errorMessage` /
+ *  `stopDetails.explanation` so loop-level salvage can classify it after the
+ *  original `Error` instance is gone. */
+export declare function isStreamEnvelopeErrorText(text: string): boolean;
 export declare function classify(error: unknown, api?: Api): number;
 /**
  * Whether an error (or message string) classifies as an account usage/quota

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

@@ -421,17 +421,27 @@ export interface BuildResponsesInputOptions<TApi extends Api> {
     preserveAssistantMessageIds?: boolean;
 }
 /**
- * Escape reserved Harmony control tokens in the client-boundary text of
- * replayed Responses input items — user/developer/system message text and
- * tool-result output. Model-owned items (assistant output, reasoning, tool-call
- * arguments) carry no client data and are returned untouched.
+ * Escape reserved Harmony control tokens in the free-text fields of replayed
+ * Responses input items: user/developer/system text, tool-result output,
+ * assistant message text, and tool-call payloads.
+ *
+ * Tool-call items are covered deliberately. The original #6913 fix skipped
+ * model-owned items on the theory that they carry no client data — but a model
+ * legitimately writing *about* Harmony samples `<|channel|>` etc. into its own
+ * `function_call.arguments`, and a full-transcript replay (stale or blocked
+ * previous_response_id, provider fallback) feeds those bytes back as input,
+ * which gpt-5.x reject with invalid_prompt / "Request blocked", permanently
+ * poisoning the session. `arguments` is a JSON document, so it uses
+ * {@link escapeHarmonyControlTokensInJson} to stay parseable. Reasoning items
+ * are left untouched: `encrypted_content` is opaque and plaintext summaries
+ * are never rendered back into the prompt.
  *
  * Native history replay pushes stored `providerPayload` items straight onto the
  * wire, bypassing {@link convertResponsesInputContent}; without this a stored
  * `input_text` carrying `<|channel|>analysis` still reaches gpt-5.x raw (#6913).
  * Callers gate on {@link isHarmonyDialectModel}. Items are copied, not mutated.
  */
-export declare function escapeReplayedClientText(items: ResponseInput): ResponseInput;
+export declare function escapeReplayedControlTokens(items: ResponseInput): ResponseInput;
 export declare function buildResponsesInput<TApi extends Api>(options: BuildResponsesInputOptions<TApi>): ResponseInput;
 export declare function convertResponsesAssistantMessage<TApi extends Api>(assistantMsg: AssistantMessage, model: Model<TApi>, msgIndex: number, knownCallIds: Set<string>, includeThinkingSignatures?: boolean, customCallIds?: Set<string>, preserveMessageIds?: boolean, supportsCustomToolCalls?: boolean, customToolWireNameMap?: ReadonlyMap<string, string>, computerCallIds?: Set<string>): ResponseInput;
 /** Appends one tool result while keeping consecutive outputs ahead of its synthetic image messages. */
@@ -516,6 +526,8 @@ export interface ProcessResponsesStreamOptions {
     requestServiceTier?: ServiceTier;
 }
 export declare function computerCallMetadata(item: ResponseComputerToolCall): ComputerToolCallMetadata;
+/** Append a native Responses image result and emit its completion event. */
+export declare function appendResponsesImageResult(output: AssistantMessage, stream: AssistantMessageEventStream, result: string): void;
 export declare function processResponsesStream<TApi extends Api>(openaiStream: AsyncIterable<ResponseStreamEvent>, output: AssistantMessage, stream: AssistantMessageEventStream, model: Model<TApi>, options?: ProcessResponsesStreamOptions): Promise<void>;
 export declare function mapOpenAIResponsesStopReason(status: ResponseStatus | undefined): StopReason;
 export declare function hasExecutableIncompleteResponsesToolCalls(output: AssistantMessage): boolean;

package/dist/types/providers/transform-messages.d.ts

@@ -13,7 +13,7 @@ import type { Api, AssistantMessage, Message, Model } from "../types.js";
  * credential redaction is enabled. Exported so hosts can route the same shapes
  * through reversible obfuscation (keyed placeholders restored before local tool
  * execution) instead of the irreversible `[*_token_redacted]` rewrite below —
- * an irreversible placeholder echoed back in edit-tool `old_text` can never
+ * an irreversible placeholder echoed back in edit-tool `old_string` can never
  * match the real bytes on disk.
  */
 export declare const SENSITIVE_TOKEN_RE: RegExp;

package/dist/types/types.d.ts

@@ -124,10 +124,10 @@ export declare function serviceTierFamily(model: ServiceTierModel): ServiceTierF
 export declare function resolveModelServiceTier(tiers: ServiceTierByFamily | null | undefined, model: Pick<Model, "provider" | "api" | "id">): ServiceTier | 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.
+ * request field. OpenAI / OpenAI-Codex accept every {@link ServiceTier};
+ * Google (Gemini API + Vertex) and OpenRouter accept `flex`/`priority`;
+ * Fireworks Serverless realizes only its Priority serving path. Anthropic is
+ * absent because it realizes `priority` via `speed: "fast"`.
  */
 export declare function shouldSendServiceTier(serviceTier: ServiceTier | null | undefined, target: Provider | ServiceTierModel | undefined): boolean;
 /**
@@ -660,6 +660,8 @@ export interface AssistantRetryRecovery {
 export interface ContextSnapshot {
     promptTokens: number;
     nonMessageTokens: number;
+    /** Estimated prompt tokens removed by local history rewrites after this provider snapshot was recorded. */
+    historyRewriteTokensRemoved?: number;
     lastMessageTimestamp?: number;
 }
 export interface AssistantMessage {

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

@@ -8,6 +8,15 @@ import type { AssistantMessage, Model, ToolCall } from "../types.js";
  * the persisted transcript keeps the byte-for-byte original.
  */
 export declare function escapeHarmonyControlTokens(text: string): string;
+/**
+ * Escape reserved Harmony control tokens inside a JSON document string (e.g.
+ * `function_call.arguments`). Doubles the backslash so the document remains
+ * valid JSON whose *decoded* strings carry the inert `<\|token\|>` spelling.
+ * `<|` cannot occur outside a string literal in valid JSON, so the blanket
+ * replace never corrupts structure; malformed documents are escaped
+ * best-effort.
+ */
+export declare function escapeHarmonyControlTokensInJson(text: string): string;
 /**
  * Whether requests to `model` are served by a Harmony-dialect backend
  * (gpt-5.x / gpt-oss), which rejects reserved control-token spellings appearing

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

@@ -9,10 +9,16 @@
  * literal enums/consts, and descriptions survive.
  */
 export interface JsonSchemaToTsOptions {
-    /** Indentation unit for nested object bodies. Default two spaces. */
+    /** Indentation unit for nested object bodies. Default two spaces (none in `harmony` style). */
     readonly indent?: string;
-    /** Emit `description` keywords as JSDoc comments on object properties. Default true. */
+    /** Emit `description` keywords as comments on object properties. Default true. */
     readonly comments?: boolean;
+    /**
+     * Output flavor. `default` renders JSDoc comments, `;` delimiters, and
+     * indented bodies; `harmony` renders the flat OpenAI-Harmony convention —
+     * `//` line comments, `,` delimiters, no indentation.
+     */
+    readonly style?: "default" | "harmony";
 }
 /** Convert a JSON Schema object into a simplified TypeScript type string. */
 export declare function jsonSchemaToTypeScript(schema: unknown, options?: JsonSchemaToTsOptions): string;

package/package.json

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

package/src/auth-broker/discover.ts

@@ -6,6 +6,7 @@
  */
 import * as path from "node:path";
 import {
+	$envExact,
 	getAgentDbPath,
 	getAgentDir,
 	getAuthBrokerSnapshotCachePath,
@@ -55,7 +56,7 @@ export function getAuthBrokerTokenFilePath(): string {
  */
 async function defaultResolveConfigValue(config: string): Promise<string | undefined> {
 	if (config.startsWith("!")) return undefined;
-	const envValue = process.env[config];
+	const envValue = $envExact(config);
 	return envValue || config;
 }
 

package/src/auth-storage.ts

@@ -12,7 +12,7 @@ import { createHash } from "node:crypto";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { parseAlibabaTokenPlanCredential } from "@oh-my-pi/pi-catalog/wire/alibaba-token-plan";
-import { $env, getAgentDbPath, getDbBusyTimeoutMs, logger } from "@oh-my-pi/pi-utils";
+import { $env, $envExact, getAgentDbPath, getDbBusyTimeoutMs, logger } from "@oh-my-pi/pi-utils";
 import type { ApiKeyResolver } from "./auth-retry";
 import * as AIError from "./error";
 import { isUsageLimitOutcome } from "./error/rate-limit";
@@ -643,7 +643,7 @@ export type AuthStorageOptions = {
  * Does NOT support "!command" syntax (that requires pi-natives).
  */
 async function defaultConfigValueResolver(config: string): Promise<string | undefined> {
-	const envValue = process.env[config];
+	const envValue = $envExact(config);
 	return envValue || config;
 }
 

package/src/dialect/examples.ts

@@ -1,25 +1,37 @@
-import type { ToolCall } from "../types";
-import { getDialectDefinition } from "./factory";
-import type { Dialect, InbandTool } from "./types";
+import { pyCall } from "./rendering";
+import type { InbandTool } from "./types";
 
 const INTENT_PLACEHOLDER = "…";
 
-export function renderToolExamples(tool: InbandTool, dialect: Dialect, intentField?: string): string {
+/**
+ * Render a tool's examples as an `<examples>` block. Calls render in Python
+ * keyword-argument syntax (`name(key="value", n=1)`) regardless of the model's
+ * tool-call dialect, so example bytes stay identical across models. Multiline
+ * string args render as verbatim `"""…"""` blocks, and a call whose only
+ * argument is a string renders as the bare value — the block already names the
+ * tool, and payload args (commands, code, patches) read best verbatim.
+ */
+export function renderToolExamples(tool: InbandTool, intentField?: string): string {
 	const examples = tool.examples;
 	if (!examples?.length) return "";
-	const definition = getDialectDefinition(dialect);
 	const renderCall = (args: Record<string, unknown>): string => {
+		let soleKey: string | undefined;
+		let argCount = 0;
+		for (const key in args) {
+			argCount++;
+			soleKey = key;
+		}
+		if (argCount === 1 && soleKey !== undefined && typeof args[soleKey] === "string") {
+			// Bare payload. The intent placeholder still rides on the envelope so
+			// intent-traced schemas (where `i` is required) keep teaching it.
+			const intentAttr = intentField ? ` ${intentField}="${INTENT_PLACEHOLDER}"` : "";
+			return `<example${intentAttr}>\n${args[soleKey]}\n</example>`;
+		}
 		// When intent tracing injects `i` into the schema, examples must show a
 		// placeholder so the model learns to emit it. Keep it first, matching the
 		// schema injection order.
 		const finalArgs = intentField ? { [intentField]: INTENT_PLACEHOLDER, ...args } : args;
-		const call: ToolCall = {
-			type: "toolCall",
-			id: "example",
-			name: tool.name,
-			arguments: finalArgs,
-		};
-		return `<example>\n${definition.renderToolCall(call, { tools: [tool], example: true }).trim()}\n</example>`;
+		return `<example>\n${pyCall(tool.name, finalArgs)}\n</example>`;
 	};
 	const parts = examples.map(ex => {
 		const head = ex.caption ? `# ${ex.caption}\n` : "";

package/src/dialect/gemini.ts

@@ -2,7 +2,13 @@ import type { Message, ToolCall } from "../types";
 import { mintToolCallId, partialSuffixOverlapAny } from "./coercion";
 import { FencedThinkingScanner } from "./fenced-thinking";
 import dialectPrompt from "./gemini.md" with { type: "text" };
-import { assistantTranscriptParts, collectToolResultRun, joinUserBodies, messageContentText } from "./rendering";
+import {
+	assistantTranscriptParts,
+	collectToolResultRun,
+	joinUserBodies,
+	messageContentText,
+	pyValue,
+} from "./rendering";
 import type {
 	DialectDefinition,
 	DialectRenderOptions,
@@ -494,11 +500,15 @@ function topLevelIndexOf(text: string, ch: string): number {
 	return -1;
 }
 
-function renderToolCall(call: ToolCall, options: DialectRenderOptions = {}): string {
-	const kwargs = Object.entries(call.arguments)
-		.map(([key, value]) => `${key}=${pyValue(value)}`)
-		.join(", ");
-	return options.example ? `${call.name}(${kwargs})` : `default_api.${call.name}(${kwargs})`;
+function renderToolCall(call: ToolCall, _options: DialectRenderOptions = {}): string {
+	// Always escaped single-line literals: the scanner round-trips this wire
+	// form through unescapePythonString, so pyCall's verbatim `"""` example
+	// blocks would corrupt backslash-bearing content.
+	let kwargs = "";
+	for (const key in call.arguments) {
+		kwargs += `${kwargs ? ", " : ""}${key}=${pyValue(call.arguments[key])}`;
+	}
+	return `default_api.${call.name}(${kwargs})`;
 }
 
 function renderAssistantToolCalls(calls: readonly ToolCall[], options: DialectRenderOptions = {}): string {
@@ -507,8 +517,7 @@ function renderAssistantToolCalls(calls: readonly ToolCall[], options: DialectRe
 		calls.length === 1
 			? renderToolCall(calls[0]!, options)
 			: `[${calls.map(call => renderToolCall(call, options)).join(", ")}]`;
-	// Examples show the bare call; the live wire form fences it as `tool_code`.
-	return options.example ? body : `${CODE_OPEN}\n${body}\n${FENCE}`;
+	return `${CODE_OPEN}\n${body}\n${FENCE}`;
 }
 
 function renderToolResults(results: readonly DialectToolResult[]): string {
@@ -560,29 +569,6 @@ function geminiTurn(role: "model" | "user", body: string): string {
 	return `<start_of_turn>${role}\n${body}<end_of_turn>\n`;
 }
 
-function pyValue(value: unknown): string {
-	if (value === null || value === undefined) return "None";
-	if (typeof value === "boolean") return value ? "True" : "False";
-	if (typeof value === "number") return Number.isFinite(value) ? String(value) : pyString(String(value));
-	if (typeof value === "string") return pyString(value);
-	if (Array.isArray(value)) return `[${value.map(pyValue).join(", ")}]`;
-	if (typeof value === "object") {
-		const entries = Object.entries(value as Record<string, unknown>);
-		return `{${entries.map(([key, val]) => `${pyString(key)}: ${pyValue(val)}`).join(", ")}}`;
-	}
-	return pyString(String(value));
-}
-
-function pyString(value: string): string {
-	const escaped = value
-		.replaceAll("\\", "\\\\")
-		.replaceAll('"', '\\"')
-		.replaceAll("\n", "\\n")
-		.replaceAll("\r", "\\r")
-		.replaceAll("\t", "\\t");
-	return `"${escaped}"`;
-}
-
 const definition: DialectDefinition = {
 	dialect: "gemini",
 	prompt: dialectPrompt,

package/src/dialect/harmony.ts

@@ -273,8 +273,7 @@ function parseRecipient(header: string): string {
 	return match?.[1] ?? "";
 }
 
-function renderToolCall(call: ToolCall, options: DialectRenderOptions = {}): string {
-	if (options.example) return stringifyJson(call.arguments);
+function renderToolCall(call: ToolCall, _options: DialectRenderOptions = {}): string {
 	return `${START}assistant${CHANNEL}commentary to=${harmonyRecipient(call.name)}${MESSAGE}${stringifyJson(call.arguments)}${CALL}`;
 }
 

package/src/dialect/inventory.ts

@@ -1,73 +1,30 @@
-import { preferredDialect } from "@oh-my-pi/pi-catalog/identity";
 import { jsonSchemaToTypeScript, toolWireSchema } from "../utils/schema";
 import { renderToolExamples } from "./examples";
 import type { InbandTool } from "./types";
 
 /**
- * Human-readable per-tool inventory: each tool renders as a `# Tool: <name>`
- * section with its description, a simplified TypeScript-style parameter
- * signature (derived from the wire JSON Schema), and examples in the model's
- * native dialect. Shared by the verbose system-prompt inventory and
- * `/dump` so both render the catalog the same way.
- *
- * `model` is a model id; the native example dialect is resolved from it
- * (`preferredDialect`, which falls back to XML for empty/unknown ids).
+ * Tool catalog in the OpenAI-Harmony `namespace functions { … }` shape: each
+ * tool renders as its full description (and Python-syntax examples) as `//`
+ * comment lines above a flat `type <name> = (_: {…});` declaration. Shared by
+ * the verbose system-prompt inventory and `/dump` so both render the catalog
+ * the same way.
  */
-export function renderToolInventory(tools: readonly InbandTool[], model: string): string {
+export function renderToolInventory(tools: readonly InbandTool[]): string {
 	if (tools.length === 0) return "";
-	const dialect = preferredDialect(model);
-	return tools
-		.map(tool => {
-			const params = jsonSchemaToTypeScript(toolWireSchema(tool));
-			const examples = renderToolExamples(tool, dialect);
-			const description = demoteDescriptionHeaders(tool.description ?? "");
-			const parts = [`# Tool: ${tool.name}`, description, "", `Parameters: ${params}`];
-			if (examples) parts.push("", examples);
-			return parts.join("\n");
-		})
-		.join("\n\n");
-}
-
-const FENCE = /^ {0,3}(`{3,}|~{3,})/;
-const ATX = /^ {0,3}#{1,6}( |\t|$)/;
-const TOP_LEVEL = /^ {0,3}#( |\t|$)/;
-
-/**
- * Each description is rendered under a `# Tool: <name>` heading. When the
- * description carries its own top-level (`# `) markdown headers they sit at the
- * same level as that wrapper, so the section structure flattens and the
- * description's headers read like sibling tools. Demote every ATX header in the
- * description by one level so the whole block nests under `# Tool: <name>`.
- *
- * Only triggered when a level-1 header is actually present — descriptions that
- * already start at `##` are left untouched. Headers inside fenced code blocks
- * are never rewritten.
- */
-function demoteDescriptionHeaders(description: string): string {
-	const lines = description.split("\n");
-
-	let fence: string | undefined;
-	let collides = false;
-	for (const line of lines) {
-		const marker = FENCE.exec(line)?.[1][0];
-		if (marker) {
-			fence = fence === undefined ? marker : fence === marker ? undefined : fence;
-		} else if (fence === undefined && TOP_LEVEL.test(line)) {
-			collides = true;
-			break;
+	const declarations = tools.map(tool => {
+		const params = jsonSchemaToTypeScript(toolWireSchema(tool), { style: "harmony" });
+		const lines: string[] = [];
+		const description = tool.description ?? "";
+		if (description) {
+			for (const line of description.split("\n")) lines.push(`// ${line}`.trimEnd());
 		}
-	}
-	if (!collides) return description;
-
-	fence = undefined;
-	for (let i = 0; i < lines.length; i++) {
-		const line = lines[i];
-		const marker = FENCE.exec(line)?.[1][0];
-		if (marker) {
-			fence = fence === undefined ? marker : fence === marker ? undefined : fence;
-		} else if (fence === undefined && ATX.test(line)) {
-			lines[i] = line.replace(/^( {0,3})#/, "$1##");
+		const examples = renderToolExamples(tool);
+		if (examples) {
+			if (description) lines.push("//");
+			for (const line of examples.split("\n")) lines.push(`// ${line}`.trimEnd());
 		}
-	}
-	return lines.join("\n");
+		lines.push(params === "{}" ? `type ${tool.name} = ();` : `type ${tool.name} = (_: ${params});`);
+		return lines.join("\n");
+	});
+	return `## functions\n\nnamespace functions {\n\n${declarations.join("\n\n")}\n\n} // namespace functions`;
 }

package/src/dialect/rendering.ts

@@ -19,6 +19,60 @@ export function stringifyJson(value: unknown): string {
 	return stringifyJsonValue(value) ?? "null";
 }
 
+/**
+ * Render `name(key=value, …)` with Python-literal argument values. Top-level
+ * multiline strings render as verbatim `"""…"""` blocks so payload-carrying
+ * args (file content, scripts, patches) keep real newlines instead of `\n`
+ * escape soup; nested values always use escaped single-line literals.
+ */
+export function pyCall(name: string, args: Record<string, unknown>): string {
+	let kwargs = "";
+	for (const key in args) {
+		kwargs += `${kwargs ? ", " : ""}${key}=${pyArgValue(args[key])}`;
+	}
+	return `${name}(${kwargs})`;
+}
+
+function pyArgValue(value: unknown): string {
+	if (typeof value === "string" && value.includes("\n")) {
+		// Verbatim `"""` fencing is only unambiguous when the content cannot
+		// collide with the fence: no `"""` inside, no quote butting against a
+		// fence edge, no trailing backslash swallowing the closer.
+		const fenceSafe =
+			!value.includes('"""') && !value.startsWith('"') && !value.endsWith('"') && !value.endsWith("\\");
+		if (fenceSafe) return `"""${value}"""`;
+	}
+	return pyValue(value);
+}
+
+/** Render a JSON-ish value as a Python literal (`True`/`False`/`None`, escaped strings, lists, dicts). */
+export function pyValue(value: unknown): string {
+	if (value === null || value === undefined) return "None";
+	if (typeof value === "boolean") return value ? "True" : "False";
+	if (typeof value === "number") return Number.isFinite(value) ? String(value) : pyString(String(value));
+	if (typeof value === "string") return pyString(value);
+	if (Array.isArray(value)) return `[${value.map(pyValue).join(", ")}]`;
+	if (typeof value === "object") {
+		const record = value as Record<string, unknown>;
+		let entries = "";
+		for (const key in record) {
+			entries += `${entries ? ", " : ""}${pyString(key)}: ${pyValue(record[key])}`;
+		}
+		return `{${entries}}`;
+	}
+	return pyString(String(value));
+}
+
+function pyString(value: string): string {
+	const escaped = value
+		.replaceAll("\\", "\\\\")
+		.replaceAll('"', '\\"')
+		.replaceAll("\n", "\\n")
+		.replaceAll("\r", "\\r")
+		.replaceAll("\t", "\\t");
+	return `"${escaped}"`;
+}
+
 export function escapeXmlAttr(value: string): string {
 	return value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 }

package/src/dialect/types.ts

@@ -27,7 +27,6 @@ export interface DialectToolResult {
 
 export interface DialectRenderOptions {
 	readonly tools?: readonly InbandTool[];
-	readonly example?: boolean;
 }
 
 export interface DialectDefinition {

package/src/error/flags.ts

@@ -270,6 +270,14 @@ export function isStreamReadErrorText(text: string): boolean {
 	return STREAM_READ_ERROR_PATTERN.test(text);
 }
 
+/** Persisted-text form of {@link isStreamEnvelopeError}: recognizes the
+ *  prefix-tagged envelope diagnostic on an aborted turn's `errorMessage` /
+ *  `stopDetails.explanation` so loop-level salvage can classify it after the
+ *  original `Error` instance is gone. */
+export function isStreamEnvelopeErrorText(text: string): boolean {
+	return text.includes(STREAM_ENVELOPE_ERROR_PREFIX);
+}
+
 function isTransientErrorText(text: string): boolean {
 	return (
 		isUnexpectedSocketCloseMessage(text) ||

package/src/providers/anthropic.ts

@@ -2563,7 +2563,22 @@ const streamAnthropicOnce = (
 					if (!sawEvent || !sawMessageStart) {
 						throw new AIError.AnthropicStreamEnvelopeError("stream ended before message_start");
 					}
+					if (!sawTerminalEnvelope) {
+						// Neither a message_delta stop_reason nor message_stop arrived: the
+						// connection died mid-generation. Finalizing the partial message as
+						// a clean "stop" would make the agent loop treat the truncated turn
+						// as complete (silent mid-sentence halt), so fail the turn. The
+						// envelope error is transparently retried before replay-unsafe
+						// content streams; afterwards it surfaces as an error turn whose
+						// complete tool calls the agent loop salvages
+						// (`recoverTransientErrorToolTurn` recognizes the envelope-error
+						// text and `retainCompletedToolCalls` drops half-streamed calls).
+						throw new AIError.AnthropicStreamEnvelopeError("stream ended before message_stop");
+					}
 					if (!sawMessageStop) {
+						// A stop_reason arrived via message_delta, so generation finished;
+						// only the trailing message_stop frame is missing (non-conforming
+						// gateway). Degrade to best-effort instead of discarding the turn.
 						reportAnthropicEnvelopeAnomaly("stream ended before message_stop");
 					}
 					if (openBlocks.size > 0) {
@@ -2780,15 +2795,48 @@ type SystemBlockOptions = {
 	cacheControl?: AnthropicCacheControl;
 };
 
-function applyClaudeCodeSystemCache(
+/**
+ * Place system-block cache breakpoints that survive volatile project context.
+ *
+ * omp normally appends its project footer (cwd, date, workspace tree) after the
+ * stable system prefix. When cwd is outside a single direct child repository,
+ * an active-repo context block follows that footer. Caching up to the last three
+ * eligible blocks therefore covers both layouts:
+ *
+ * - stable prefix, project footer
+ * - stable prefix, project footer, active-repo context
+ *
+ * A footer change can then fall back to the stable-prefix entry instead of
+ * re-writing the entire system cache (issue #7324).
+ *
+ * @returns breakpoints placed, capped by `maxBreakpoints`.
+ */
+function cacheSystemPrefixBreakpoints(
 	blocks: AnthropicSystemBlock[],
 	cacheControl: AnthropicCacheControl | undefined,
+	maxBreakpoints: number,
+	firstCacheableIndex: number,
 ): number {
-	if (!cacheControl || blocks.length === 0) return 0;
-	const lastIndex = blocks.length - 1;
-	if (blocks[lastIndex].cache_control != null) return 0;
-	blocks[lastIndex] = { ...blocks[lastIndex], cache_control: cloneAnthropicCacheControl(cacheControl) };
-	return 1;
+	if (!cacheControl || maxBreakpoints <= 0) return 0;
+	let placed = 0;
+	for (let index = blocks.length - 1; index >= firstCacheableIndex && placed < maxBreakpoints; index--) {
+		if (blocks[index].cache_control != null) continue;
+		blocks[index] = { ...blocks[index], cache_control: cloneAnthropicCacheControl(cacheControl) };
+		placed++;
+	}
+	return placed;
+}
+
+/**
+ * First system-block index that may carry a cache breakpoint. Skips the OAuth
+ * cloak blocks that must stay uncached: the CC billing header (block 0, a
+ * per-request fingerprint) and the Claude Code identity instruction (block 1).
+ */
+function firstCacheableSystemIndex(blocks: readonly AnthropicSystemBlock[]): number {
+	let index = 0;
+	if (blocks[index]?.text?.startsWith(CLAUDE_BILLING_HEADER_PREFIX)) index++;
+	if (blocks[index]?.text === claudeCodeSystemInstruction) index++;
+	return index;
 }
 
 export function buildAnthropicSystemBlocks(
@@ -2812,7 +2860,7 @@ export function buildAnthropicSystemBlocks(
 		for (const prompt of sanitizedPrompts) {
 			blocks.push({ type: "text", text: prompt });
 		}
-		applyClaudeCodeSystemCache(blocks, cacheControl);
+		cacheSystemPrefixBreakpoints(blocks, cacheControl, 3, firstCacheableSystemIndex(blocks));
 
 		return blocks;
 	}
@@ -3083,17 +3131,6 @@ type CacheControlBlock = {
 	cache_control?: AnthropicCacheControl | null;
 };
 
-function applyCacheControlToLastBlock<T extends CacheControlBlock>(
-	blocks: T[],
-	cacheControl: AnthropicCacheControl,
-): boolean {
-	if (blocks.length === 0) return false;
-	const lastIndex = blocks.length - 1;
-	if (blocks[lastIndex].cache_control != null) return false;
-	blocks[lastIndex] = { ...blocks[lastIndex], cache_control: cloneAnthropicCacheControl(cacheControl) };
-	return true;
-}
-
 function applyCacheControlToLastTextBlock(
 	blocks: Array<ContentBlockParam & CacheControlBlock>,
 	cacheControl: AnthropicCacheControl,
@@ -3127,24 +3164,32 @@ function applyPromptCaching(params: MessageCreateParamsStreaming, cacheControl?:
 	let isCCLayout = false;
 
 	if (params.system && Array.isArray(params.system) && params.system.length > 0) {
-		isCCLayout =
-			params.system.length >= 3 &&
-			(params.system[0] as { text?: string }).text?.startsWith(CLAUDE_BILLING_HEADER_PREFIX) === true;
-		if (isCCLayout) {
-			const placed = Math.min(
-				MAX_CACHE_BREAKPOINTS - cacheBreakpointsUsed,
-				applyClaudeCodeSystemCache(params.system as AnthropicSystemBlock[], cacheControl),
-			);
-			cacheBreakpointsUsed += placed;
-		} else if (applyCacheControlToLastBlock(params.system, cacheControl)) {
-			cacheBreakpointsUsed++;
-		}
+		isCCLayout = params.system[0]?.text?.startsWith(CLAUDE_BILLING_HEADER_PREFIX) === true;
+		const maxSystemBreakpoints = Math.min(3, MAX_CACHE_BREAKPOINTS - cacheBreakpointsUsed);
+		cacheBreakpointsUsed += cacheSystemPrefixBreakpoints(
+			params.system as AnthropicSystemBlock[],
+			cacheControl,
+			maxSystemBreakpoints,
+			isCCLayout ? firstCacheableSystemIndex(params.system as AnthropicSystemBlock[]) : 0,
+		);
 	}
 
 	if (cacheBreakpointsUsed >= MAX_CACHE_BREAKPOINTS) return;
 
-	const start = isCCLayout ? Math.max(0, params.messages.length - 1) : Math.max(0, params.messages.length - 2);
-	for (let i = start; i < params.messages.length; i++) {
+	// `convertAnthropicMessages` appends this neutral pad after a trailing
+	// assistant because Anthropic rejects assistant-prefill endings. It is absent
+	// from the next normal turn, so caching it wastes a scarce breakpoint; anchor
+	// the cache window on the preceding real assistant instead.
+	const trailingIndex = params.messages.length - 1;
+	const trailingMessage = params.messages[trailingIndex];
+	const hasTrailingAssistantPad =
+		trailingMessage?.role === "user" &&
+		trailingMessage.content === "Continue." &&
+		params.messages[trailingIndex - 1]?.role === "assistant";
+	const messageEnd = hasTrailingAssistantPad ? trailingIndex - 1 : trailingIndex;
+	const messageWindowSize = isCCLayout ? 1 : 2;
+	const start = Math.max(0, messageEnd - messageWindowSize + 1);
+	for (let i = messageEnd; i >= start; i--) {
 		if (cacheBreakpointsUsed >= MAX_CACHE_BREAKPOINTS) break;
 		const message = params.messages[i];
 		if (!message) continue;

package/src/providers/cursor.ts

@@ -1816,11 +1816,14 @@ async function handleExecServerMessage(
 		case "piEditArgs": {
 			const args = execMsg.message.value;
 			const toolCallId = crypto.randomUUID();
-			// `PiEditReplacement` is the local `edit` tool's replace mode verbatim:
-			// snake_case `old_text`/`new_text` entries against one path.
+			// `PiEditReplacement` maps onto the local `edit` tool's replace mode:
+			// one snake_case `old_string`/`new_string` per call. Multi-replacement
+			// frames display the first replacement; the exec handler applies all.
+			const firstEdit = args.edits[0];
 			synthesizeCursorExecToolCall(output, stream, state, toolCallId, "edit", {
 				path: args.path,
-				edits: args.edits.map(edit => ({ old_text: edit.oldText, new_text: edit.newText })),
+				old_string: firstEdit?.oldText ?? "",
+				new_string: firstEdit?.newText ?? "",
 			});
 			const { execResult } = await resolveExecHandler(
 				{ args, toolCallId },

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

@@ -84,6 +84,7 @@ import type {
 	ResponseFunctionToolCall,
 	ResponseInput,
 	ResponseInputContent,
+	ResponseOutputItem,
 	ResponseOutputMessage,
 	ResponseReasoningItem,
 	ResponseStatus,
@@ -96,6 +97,7 @@ import {
 	appendReasoningSummaryPart,
 	appendReasoningSummaryPartDone,
 	appendReasoningSummaryTextDelta,
+	appendResponsesImageResult,
 	appendResponsesToolResultMessages,
 	applyOpenAIServiceTier,
 	applyReasoningSummaryDone,
@@ -106,7 +108,7 @@ import {
 	createSequentialCutoffSummaryState,
 	encodeResponsesToolCallId,
 	encodeTextSignatureV1,
-	escapeReplayedClientText,
+	escapeReplayedControlTokens,
 	finalizeCustomToolCallInputDone,
 	finalizeMessageText,
 	finalizePendingResponsesToolCalls,
@@ -371,7 +373,8 @@ type CodexEventItem =
 	| ResponseOutputMessage
 	| ResponseFunctionToolCall
 	| ResponseCustomToolCall
-	| ResponseComputerToolCall;
+	| ResponseComputerToolCall
+	| ResponseOutputItem.ImageGenerationCall;
 type CodexOutputBlock =
 	| ThinkingContent
 	| TextContent
@@ -2289,6 +2292,7 @@ class CodexStreamProcessor {
 		const rawItem = rawEvent.item;
 		if (!rawItem || typeof rawItem !== "object") return;
 		const item = structuredCloneJSON(rawItem) as CodexEventItem;
+		if (item.type === "image_generation_call" && item.result) item.status = "completed";
 		runtime.nativeOutputItems.push(item as unknown as Record<string, unknown>);
 
 		// Match the finalization to the OPEN ITEM that started this block, not the
@@ -2301,6 +2305,12 @@ class CodexStreamProcessor {
 		const block = entry?.block ?? null;
 		const contentIndex = entry?.contentIndex ?? output.content.length - 1;
 
+		if (item.type === "image_generation_call" && item.result) {
+			appendResponsesImageResult(output, stream, item.result);
+			runtime.closeOpenItem(entry);
+			return;
+		}
+
 		if (item.type === "reasoning" && block?.type === "thinking") {
 			this.#flushSummaryDeltas(entry);
 			block.thinking = finalizeReasoningThinking(
@@ -4339,6 +4349,9 @@ function convertMessages(model: Model<"openai-codex-responses">, context: Contex
 	};
 
 	const transformedMessages = transformMessages(context.messages, model, normalizeToolCallId);
+	// gpt-5.x reject raw Harmony control-token spellings anywhere in replayed
+	// input, including the model's own tool-call arguments (#6913).
+	const escapeControlTokens = isHarmonyDialectModel(model);
 	let msgIndex = 0;
 	// Track call_ids that originated as custom tool calls so paired tool-result
 	// messages can be replayed as `custom_tool_call_output` rather than
@@ -4368,7 +4381,7 @@ function convertMessages(model: Model<"openai-codex-responses">, context: Contex
 						knownCallIds.add(item.call_id);
 					}
 				}
-				messages.push(...(isHarmonyDialectModel(model) ? escapeReplayedClientText(replayItems) : replayItems));
+				messages.push(...(escapeControlTokens ? escapeReplayedControlTokens(replayItems) : replayItems));
 				msgIndex += 1;
 				continue;
 			}
@@ -4394,10 +4407,11 @@ function convertMessages(model: Model<"openai-codex-responses">, context: Contex
 			if (historyItems) {
 				const sanitizedHistoryItems = sanitizeOpenAIResponsesAssistantHistoryItemsForReplay(historyItems);
 				if (sanitizedHistoryItems) {
-					const replayItems =
+					const rawReplayItems =
 						model.supportsComputerUse === true
 							? sanitizedHistoryItems
 							: unrollCodexComputerItems(sanitizedHistoryItems, model.compat.supportsImageDetailOriginal);
+					const replayItems = escapeControlTokens ? escapeReplayedControlTokens(rawReplayItems) : rawReplayItems;
 					for (const item of replayItems) {
 						if (item.type === "custom_tool_call") {
 							customCallIds.add(item.call_id);
@@ -4435,7 +4449,7 @@ function convertMessages(model: Model<"openai-codex-responses">, context: Contex
 				? sanitizeOpenAIResponsesAssistantFallbackItemsForReplay(convertedOutputItems)
 				: convertedOutputItems;
 			if (outputItems.length > 0) {
-				messages.push(...outputItems);
+				messages.push(...(escapeControlTokens ? escapeReplayedControlTokens(outputItems) : outputItems));
 			}
 			msgIndex += 1;
 			continue;

package/src/providers/openai-shared.ts

@@ -78,7 +78,11 @@ import {
 	kStreamingPartialJson,
 } from "../utils/block-symbols";
 import type { AssistantMessageEventStream } from "../utils/event-stream";
-import { escapeHarmonyControlTokens, isHarmonyDialectModel } from "../utils/harmony-leak";
+import {
+	escapeHarmonyControlTokens,
+	escapeHarmonyControlTokensInJson,
+	isHarmonyDialectModel,
+} from "../utils/harmony-leak";
 import type { CapturedHttpErrorResponse } from "../utils/http-inspector";
 import { getOpenRouterHeaders } from "../utils/openrouter-headers";
 import { isForcedToolChoice } from "../utils/tool-choice";
@@ -329,9 +333,7 @@ export function applyOpenAIServiceTier(
 	model: Pick<Model, "provider" | "api" | "id">,
 ): void {
 	if (!shouldSendServiceTier(serviceTier, model)) return;
-	if (serviceTier === "flex" || serviceTier === "scale" || serviceTier === "priority") {
-		params.service_tier = serviceTier;
-	}
+	params.service_tier = serviceTier;
 }
 
 /**
@@ -1636,39 +1638,71 @@ export interface BuildResponsesInputOptions<TApi extends Api> {
 }
 
 /**
- * Escape reserved Harmony control tokens in the client-boundary text of
- * replayed Responses input items — user/developer/system message text and
- * tool-result output. Model-owned items (assistant output, reasoning, tool-call
- * arguments) carry no client data and are returned untouched.
+ * Escape reserved Harmony control tokens in the free-text fields of replayed
+ * Responses input items: user/developer/system text, tool-result output,
+ * assistant message text, and tool-call payloads.
+ *
+ * Tool-call items are covered deliberately. The original #6913 fix skipped
+ * model-owned items on the theory that they carry no client data — but a model
+ * legitimately writing *about* Harmony samples `<|channel|>` etc. into its own
+ * `function_call.arguments`, and a full-transcript replay (stale or blocked
+ * previous_response_id, provider fallback) feeds those bytes back as input,
+ * which gpt-5.x reject with invalid_prompt / "Request blocked", permanently
+ * poisoning the session. `arguments` is a JSON document, so it uses
+ * {@link escapeHarmonyControlTokensInJson} to stay parseable. Reasoning items
+ * are left untouched: `encrypted_content` is opaque and plaintext summaries
+ * are never rendered back into the prompt.
  *
  * Native history replay pushes stored `providerPayload` items straight onto the
  * wire, bypassing {@link convertResponsesInputContent}; without this a stored
  * `input_text` carrying `<|channel|>analysis` still reaches gpt-5.x raw (#6913).
  * Callers gate on {@link isHarmonyDialectModel}. Items are copied, not mutated.
  */
-export function escapeReplayedClientText(items: ResponseInput): ResponseInput {
+export function escapeReplayedControlTokens(items: ResponseInput): ResponseInput {
 	return items.map(item => {
 		if (item.type === "function_call_output" || item.type === "custom_tool_call_output") {
 			return typeof item.output === "string" ? { ...item, output: escapeHarmonyControlTokens(item.output) } : item;
 		}
+		if (item.type === "function_call") {
+			return typeof item.arguments === "string"
+				? { ...item, arguments: escapeHarmonyControlTokensInJson(item.arguments) }
+				: item;
+		}
+		if (item.type === "custom_tool_call") {
+			return typeof item.input === "string" ? { ...item, input: escapeHarmonyControlTokens(item.input) } : item;
+		}
 		// EasyInputMessage may omit `type` (`{ role, content }`); the responses
 		// server persists it verbatim, so treat missing type as a message too.
 		const isTypedMessage = item.type === "message" || item.type === undefined;
-		if (isTypedMessage && "role" in item && "content" in item) {
-			const role = item.role;
-			if (role !== "user" && role !== "developer" && role !== "system") return item;
-			const content = item.content;
-			if (typeof content === "string") {
-				return { ...item, content: escapeHarmonyControlTokens(content) };
-			}
-			if (Array.isArray(content)) {
+		if (!isTypedMessage || !("role" in item) || !("content" in item)) return item;
+		if (item.role === "assistant") {
+			// Assistant output text is model-owned but equally capable of carrying
+			// control tokens as data. `status` discriminates ResponseOutputMessage.
+			if ("status" in item && Array.isArray(item.content)) {
 				return {
 					...item,
-					content: content.map(part =>
-						part.type === "input_text" ? { ...part, text: escapeHarmonyControlTokens(part.text) } : part,
+					content: item.content.map(part =>
+						part.type === "output_text"
+							? { ...part, text: escapeHarmonyControlTokens(part.text) }
+							: part.type === "refusal"
+								? { ...part, refusal: escapeHarmonyControlTokens(part.refusal) }
+								: part,
 					),
 				};
 			}
+			return item;
+		}
+		const content = item.content;
+		if (typeof content === "string") {
+			return { ...item, content: escapeHarmonyControlTokens(content) };
+		}
+		if (Array.isArray(content)) {
+			return {
+				...item,
+				content: content.map(part =>
+					part.type === "input_text" ? { ...part, text: escapeHarmonyControlTokens(part.text) } : part,
+				),
+			};
 		}
 		return item;
 	});
@@ -1733,7 +1767,7 @@ export function buildResponsesInput<TApi extends Api>(options: BuildResponsesInp
 					customToolWireNameMap,
 					options.model.supportsComputerUse === true,
 				);
-				messages.push(...(escapeControlTokens ? escapeReplayedClientText(replayItems) : replayItems));
+				messages.push(...(escapeControlTokens ? escapeReplayedControlTokens(replayItems) : replayItems));
 				knownCallIds = collectKnownCallIds(messages);
 				for (const id of collectCustomCallIds(messages)) customCallIds.add(id);
 				for (const id of collectComputerCallIds(messages)) computerCallIds.add(id);
@@ -1794,10 +1828,16 @@ export function buildResponsesInput<TApi extends Api>(options: BuildResponsesInp
 						)
 					: undefined;
 				if (nativeReplayEnabled && sanitizedHistoryItems) {
+					// Model-owned replay items can carry reserved control-token
+					// spellings as data (the model writing *about* Harmony); escape the
+					// transport copy just like client turns.
+					const wireItems = escapeControlTokens
+						? escapeReplayedControlTokens(sanitizedHistoryItems)
+						: sanitizedHistoryItems;
 					if (providerPayload?.dt) {
-						messages.push(...sanitizedHistoryItems);
+						messages.push(...wireItems);
 					} else {
-						messages.splice(0, messages.length, ...sanitizedHistoryItems);
+						messages.splice(0, messages.length, ...wireItems);
 						customCallIds.clear();
 						computerCallIds.clear();
 					}
@@ -1826,7 +1866,7 @@ export function buildResponsesInput<TApi extends Api>(options: BuildResponsesInp
 				? sanitizeOpenAIResponsesAssistantFallbackItemsForReplay(convertedOutputItems)
 				: convertedOutputItems;
 			if (outputItems.length === 0) continue;
-			messages.push(...outputItems);
+			messages.push(...(escapeControlTokens ? escapeReplayedControlTokens(outputItems) : outputItems));
 		} else if (msg.role === "toolResult") {
 			appendResponsesToolResultMessages(
 				messages,
@@ -2419,6 +2459,26 @@ export function computerCallMetadata(item: ResponseComputerToolCall): ComputerTo
 	};
 }
 
+/** Append a native Responses image result and emit its completion event. */
+export function appendResponsesImageResult(
+	output: AssistantMessage,
+	stream: AssistantMessageEventStream,
+	result: string,
+): void {
+	const image: ImageContent = {
+		type: "image",
+		data: result,
+		mimeType: parseImageMetadata(Buffer.from(result, "base64"))?.mimeType ?? "image/png",
+	};
+	output.content.push(image);
+	stream.push({
+		type: "image_end",
+		contentIndex: output.content.length - 1,
+		content: image,
+		partial: output,
+	});
+}
+
 export async function processResponsesStream<TApi extends Api>(
 	openaiStream: AsyncIterable<ResponseStreamEvent>,
 	output: AssistantMessage,
@@ -2932,18 +2992,7 @@ export async function processResponsesStream<TApi extends Api>(
 				closeOpenItem(event.output_index, item.id, entry, item.call_id, prefixedFunctionCallItemKey(item.call_id));
 				stream.push({ type: "toolcall_end", contentIndex, toolCall, partial: output });
 			} else if (item.type === "image_generation_call" && item.status === "completed" && item.result) {
-				const image: ImageContent = {
-					type: "image",
-					data: item.result,
-					mimeType: parseImageMetadata(Buffer.from(item.result, "base64"))?.mimeType ?? "image/png",
-				};
-				output.content.push(image);
-				stream.push({
-					type: "image_end",
-					contentIndex: output.content.length - 1,
-					content: image,
-					partial: output,
-				});
+				appendResponsesImageResult(output, stream, item.result);
 			}
 		} else if (terminalEvent) {
 			const response = terminalEvent.response;

package/src/providers/transform-messages.ts

@@ -300,7 +300,7 @@ function normalizeAnthropicTargetToolCallId<TApi extends Api>(
  * credential redaction is enabled. Exported so hosts can route the same shapes
  * through reversible obfuscation (keyed placeholders restored before local tool
  * execution) instead of the irreversible `[*_token_redacted]` rewrite below —
- * an irreversible placeholder echoed back in edit-tool `old_text` can never
+ * an irreversible placeholder echoed back in edit-tool `old_string` can never
  * match the real bytes on disk.
  */
 export const SENSITIVE_TOKEN_RE =

package/src/types.ts

@@ -214,10 +214,10 @@ export function resolveModelServiceTier(
 
 /**
  * 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.
+ * request field. OpenAI / OpenAI-Codex accept every {@link ServiceTier};
+ * Google (Gemini API + Vertex) and OpenRouter accept `flex`/`priority`;
+ * Fireworks Serverless realizes only its Priority serving path. Anthropic is
+ * absent because it realizes `priority` via `speed: "fast"`.
  */
 export function shouldSendServiceTier(
 	serviceTier: ServiceTier | null | undefined,
@@ -225,12 +225,11 @@ export function shouldSendServiceTier(
 ): boolean {
 	if (!serviceTier) return false;
 	const provider = typeof target === "string" ? target : target?.provider;
-	if (provider === "openai" || provider === "openai-codex" || provider === "openrouter") {
-		return serviceTier === "flex" || serviceTier === "scale" || serviceTier === "priority";
-	}
-	if (typeof target !== "string" && target && isOpenAIServiceTierModel(target)) {
+	if (provider === "openai" || provider === "openai-codex") return true;
+	if (provider === "openrouter") {
 		return serviceTier === "flex" || serviceTier === "scale" || serviceTier === "priority";
 	}
+	if (typeof target !== "string" && target && isOpenAIServiceTierModel(target)) return true;
 	if (provider === "google") {
 		return serviceTier === "flex" || serviceTier === "priority";
 	}
@@ -844,6 +843,8 @@ export interface AssistantRetryRecovery {
 export interface ContextSnapshot {
 	promptTokens: number; // authoritative provider prompt/input tokens
 	nonMessageTokens: number; // estimated non-message total at send time
+	/** Estimated prompt tokens removed by local history rewrites after this provider snapshot was recorded. */
+	historyRewriteTokensRemoved?: number;
 	lastMessageTimestamp?: number;
 }
 

package/src/utils/harmony-leak.ts

@@ -35,6 +35,18 @@ export function escapeHarmonyControlTokens(text: string): string {
 	return text.replace(HARMONY_CONTROL_TOKEN_ESCAPE_RE, "<\\|$1\\|>");
 }
 
+/**
+ * Escape reserved Harmony control tokens inside a JSON document string (e.g.
+ * `function_call.arguments`). Doubles the backslash so the document remains
+ * valid JSON whose *decoded* strings carry the inert `<\|token\|>` spelling.
+ * `<|` cannot occur outside a string literal in valid JSON, so the blanket
+ * replace never corrupts structure; malformed documents are escaped
+ * best-effort.
+ */
+export function escapeHarmonyControlTokensInJson(text: string): string {
+	return text.replace(HARMONY_CONTROL_TOKEN_ESCAPE_RE, "<\\\\|$1\\\\|>");
+}
+
 /**
  * Whether requests to `model` are served by a Harmony-dialect backend
  * (gpt-5.x / gpt-oss), which rejects reserved control-token spellings appearing

package/src/utils/schema/typescript.ts

@@ -12,15 +12,22 @@
 import { isJsonObject } from "./types";
 
 export interface JsonSchemaToTsOptions {
-	/** Indentation unit for nested object bodies. Default two spaces. */
+	/** Indentation unit for nested object bodies. Default two spaces (none in `harmony` style). */
 	readonly indent?: string;
-	/** Emit `description` keywords as JSDoc comments on object properties. Default true. */
+	/** Emit `description` keywords as comments on object properties. Default true. */
 	readonly comments?: boolean;
+	/**
+	 * Output flavor. `default` renders JSDoc comments, `;` delimiters, and
+	 * indented bodies; `harmony` renders the flat OpenAI-Harmony convention —
+	 * `//` line comments, `,` delimiters, no indentation.
+	 */
+	readonly style?: "default" | "harmony";
 }
 
 interface Ctx {
 	readonly indent: string;
 	readonly comments: boolean;
+	readonly harmony: boolean;
 	readonly defs: Record<string, unknown> | undefined;
 	readonly seen: Set<unknown>;
 }
@@ -48,7 +55,11 @@ function joinUnion(parts: readonly string[]): string {
 	return unique.length > 0 ? unique.join(" | ") : "never";
 }
 
-function emitJsDoc(lines: string[], description: string, pad: string): void {
+function emitDescription(lines: string[], description: string, ctx: Ctx, pad: string): void {
+	if (ctx.harmony) {
+		for (const line of description.split("\n")) lines.push(`${pad}// ${line}`.trimEnd());
+		return;
+	}
 	// `* /` keeps a stray closing token inside the description from ending the comment.
 	const safe = description.replace(/\*\//g, "* /");
 	if (!safe.includes("\n")) {
@@ -85,6 +96,7 @@ function convertObject(node: Record<string, unknown>, ctx: Ctx, pad: string): st
 		const required = new Set(
 			Array.isArray(node.required) ? node.required.filter((key): key is string => typeof key === "string") : [],
 		);
+		const delimiter = ctx.harmony ? "," : ";";
 		for (const key in properties) {
 			const value = properties[key];
 			if (
@@ -93,11 +105,11 @@ function convertObject(node: Record<string, unknown>, ctx: Ctx, pad: string): st
 				typeof value.description === "string" &&
 				value.description.length > 0
 			) {
-				emitJsDoc(body, value.description, childPad);
+				emitDescription(body, value.description, ctx, childPad);
 			}
 			const optional = required.has(key) ? "" : "?";
 			const name = SAFE_KEY.test(key) ? key : JSON.stringify(key);
-			body.push(`${childPad}${name}${optional}: ${convert(value, ctx, childPad)};`);
+			body.push(`${childPad}${name}${optional}: ${convert(value, ctx, childPad)}${delimiter}`);
 		}
 	}
 
@@ -110,7 +122,7 @@ function convertObject(node: Record<string, unknown>, ctx: Ctx, pad: string): st
 
 	// Named properties alongside a free-form value schema → index signature.
 	if (isJsonObject(additional)) {
-		body.push(`${childPad}[key: string]: ${convert(additional, ctx, childPad)};`);
+		body.push(`${childPad}[key: string]: ${convert(additional, ctx, childPad)}${ctx.harmony ? "," : ";"}`);
 	}
 	return `{\n${body.join("\n")}\n${pad}}`;
 }
@@ -188,9 +200,11 @@ export function jsonSchemaToTypeScript(schema: unknown, options?: JsonSchemaToTs
 			}
 		}
 	}
+	const harmony = options?.style === "harmony";
 	const ctx: Ctx = {
-		indent: options?.indent ?? "  ",
+		indent: options?.indent ?? (harmony ? "" : "  "),
 		comments: options?.comments ?? true,
+		harmony,
 		defs,
 		seen: new Set(),
 	};

package/src/utils.ts

@@ -403,7 +403,7 @@ function sanitizeOpenAIResponsesReasoningItemForReplay(
 function sanitizeOpenAIResponsesImageGenerationCallForReplay(
 	item: Record<string, unknown>,
 ): ResponseInputItem.ImageGenerationCall | undefined {
-	if (typeof item.id !== "string" || item.status !== "completed" || typeof item.result !== "string") {
+	if (typeof item.id !== "string" || typeof item.result !== "string" || item.result.length === 0) {
 		return undefined;
 	}
 	return {