@oh-my-pi/pi-agent-core 18.15.0 → 18.17.0

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 ## [Unreleased]
 
+## [18.17.0] - 2026-11-06
+
+### Added
+
+- Added `Agent.queuedMessageGate` to filter queued messages before delivery and observe claimed messages returned undelivered.
+- Added `wireToolsFingerprint()`, returning a hash of the tool specs sent with a request.
+
+## [18.16.0] - 2026-11-02
+
+### Changed
+
+- Deprecated `createFileOps`, `computeFileLists`, `formatFileOperations`, `upsertFileOperations`, `isUrlSchemePath` and `FileOperations` in `@oh-my-pi/pi-agent-core/compaction`; they now re-export `@oh-my-pi/snapcompact`, which callers should import directly
+
+### Fixed
+
+- Context estimates for a model without a known tokenizer family (Gemini, Grok and the like), and token counts made without a model (compress metrics, the legacy `estimateTokens` export), count text in o200k_base instead of guessing 4 bytes per token, which undercounted what those providers bill by 11–48% on code-heavy sessions and let compaction fire late after a switch to them ([#17607](https://github.com/can1357/oh-my-pi/pull/17607) by [@will-bogusz](https://github.com/will-bogusz))
+- Context estimates no longer charge a reader another model's thinking signatures or redacted thinking, which the request strips: a Claude session switched to Grok or Gemini, including Gemini through Factory, counted them as text ([#17607](https://github.com/can1357/oh-my-pi/pull/17607) by [@will-bogusz](https://github.com/will-bogusz))
+
+### Removed
+
+- Removed `PI_TOKENIZER_ACCURATE`: every model is now counted with a native tokenizer ([#17607](https://github.com/can1357/oh-my-pi/pull/17607) by [@will-bogusz](https://github.com/will-bogusz))
+
 ## [18.15.0] - 2026-11-01
 
 ### Fixed

package/dist/types/agent-loop.d.ts

@@ -102,6 +102,8 @@ export declare function normalizeMessagesForProvider(messages: Context["messages
 export interface NormalizeToolsOptions {
     /** Inject the `i` intent field into tool schemas (subject to `PI_NO_INTENT`). */
     injectIntent: boolean;
+    /** Schema description of the injected `i` field; `PI_INTENT_DESC` overrides it. Default `concise intent`. */
+    intentDescription?: string;
     /** Strip descriptions from the wire specs when the catalog rides in the system prompt. */
     pruneDescriptions?: boolean;
 }

package/dist/types/agent.d.ts

@@ -4,7 +4,7 @@ import type { HarmonyAuditEvent } from "@oh-my-pi/pi-ai/utils/harmony-leak";
 import type { AppendOnlyContextManager } from "./append-only-context.js";
 import { SentToolDefinitions } from "./sent-tool-definitions.js";
 import { Tokenizer } from "./tokenizer.js";
-import type { AgentBeforeModelCall, AgentContext, AgentEvent, AgentLoopConfig, AgentMessage, AgentState, AgentTool, AgentToolContext, AgentTurnEndContext, AsideBoundary, AsideMessage, PrepareQueuedMessages, SpeculativeToolExecutionConfig, StreamFn, ToolCallContext, ToolChoiceDirective } from "./types.js";
+import type { AgentBeforeModelCall, AgentContext, AgentEvent, AgentLoopConfig, AgentMessage, AgentState, AgentTool, AgentToolContext, AgentTurnEndContext, AsideBoundary, AsideMessage, PrepareQueuedMessages, QueuedMessageGate, SpeculativeToolExecutionConfig, StreamFn, ToolCallContext, ToolChoiceDirective } from "./types.js";
 export declare class AgentBusyError extends Error {
     constructor(message?: string);
 }
@@ -157,6 +157,8 @@ export interface AgentOptions {
     suggestFallbackToolNames?: () => Iterable<string>;
     /** Enable intent tracing schema injection/stripping in the harness. */
     intentTracing?: boolean;
+    /** Schema description of the injected intent field; `PI_INTENT_DESC` overrides it. Default `concise intent`. */
+    intentDescription?: string;
     /**
      * Strip tool descriptions from provider-bound tool specs (top-level + nested
      * schema annotations). Use when the full catalog is rendered into the system
@@ -252,6 +254,12 @@ export declare class Agent {
     getApiKey?: (model: Model) => Promise<ApiKey | undefined> | ApiKey | undefined;
     /** Prepare actual queue deliveries after dequeue gates; commit runs only while ownership remains valid. */
     prepareQueuedMessages?: PrepareQueuedMessages;
+    /**
+     * Consulted synchronously whenever queued messages are removed for delivery and
+     * told about claimed messages that went back undelivered (see {@link QueuedMessageGate}).
+     * Unset, batches are taken as they are.
+     */
+    queuedMessageGate?: QueuedMessageGate;
     /**
      * Hook invoked after tool arguments are validated and before execution.
      * Reassign at any time to swap the implementation (e.g. on extension reload).
@@ -405,6 +413,8 @@ export declare class Agent {
     /** Inject/strip the intent field on tool calls; applies from the next prompt run. */
     get intentTracing(): boolean;
     set intentTracing(value: boolean);
+    /** The intent field's schema description this agent was built with (`PI_INTENT_DESC` still overrides it). */
+    get intentDescription(): string | undefined;
     /** Abort the provider request on a fabricated tool result; applies from the next prompt run. */
     get abortOnFabricatedToolResult(): boolean | undefined;
     set abortOnFabricatedToolResult(value: boolean | undefined);

package/dist/types/append-only-context.d.ts

@@ -25,6 +25,8 @@ export interface StablePrefixSnapshot {
 export interface BuildOptions {
     /** Inject the `i` intent field into tool schemas (must match agent-loop's normalizeTools). */
     intentTracing: boolean;
+    /** Schema description of the injected `i` field (must match agent-loop's normalizeTools). */
+    intentDescription?: string;
     /** Strip tool descriptions from the provider-bound specs (must match normalizeTools). */
     pruneToolDescriptions?: boolean;
 }
@@ -125,3 +127,10 @@ export declare class AppendOnlyContextManager {
     invalidate(): void;
     reset(context: AgentContext, options: BuildOptions): void;
 }
+/**
+ * Fingerprint of the tool specs a request built with `options` sends: the
+ * tools half of the prefix fingerprint, for a caller that compares tool sets
+ * across requests. A same-name tool whose description, schema, examples,
+ * `strict`, `customFormat` or `customWireName` changed makes another one.
+ */
+export declare function wireToolsFingerprint(tools: AgentContext["tools"], options: BuildOptions): string;

package/dist/types/compaction/branch-summarization.d.ts

@@ -5,12 +5,12 @@
  * a summary of the branch being left so context isn't lost.
  */
 import type { Api, ApiKey, AssistantMessage, Context, Model, SimpleStreamOptions } from "@oh-my-pi/pi-ai";
+import * as snapcompact from "@oh-my-pi/snapcompact";
 import { type AgentTelemetry } from "../telemetry.js";
 import { Tokenizer } from "../tokenizer.js";
 import type { AgentMessage } from "../types.js";
 import type { ReadonlySessionManager, SessionEntry } from "./entries.js";
 import { type ConvertToLlm } from "./messages.js";
-import { type FileOperations } from "./utils.js";
 export interface BranchSummaryResult {
     summary?: string;
     readFiles?: string[];
@@ -23,12 +23,11 @@ export interface BranchSummaryDetails {
     readFiles: string[];
     modifiedFiles: string[];
 }
-export type { FileOperations } from "./utils.js";
 export interface BranchPreparation {
     /** Messages extracted for summarization, in chronological order */
     messages: AgentMessage[];
     /** File operations extracted from tool calls */
-    fileOps: FileOperations;
+    fileOps: snapcompact.FileOperations;
     /** Total estimated tokens in messages */
     totalTokens: number;
 }

package/dist/types/compaction/compaction.d.ts

@@ -5,13 +5,13 @@
  * and after compaction the session is reloaded.
  */
 import { type Api, type ApiKey, type AssistantMessage, type CodexCompactionContext, type Context, type FetchImpl, type MessageAttribution, type Model, type OneshotRetryOptions, type ProviderSessionState, type SimpleStreamOptions, type Tool, type Usage } from "@oh-my-pi/pi-ai";
+import * as snapcompact from "@oh-my-pi/snapcompact";
 import { type AgentTelemetry } from "../telemetry.js";
 import { ThinkingLevel } from "../thinking.js";
 import { Tokenizer } from "../tokenizer.js";
 import type { AgentMessage } from "../types.js";
 import type { SessionEntry } from "./entries.js";
 import { type ConvertToLlm } from "./messages.js";
-import { type FileOperations } from "./utils.js";
 /** Details stored in CompactionEntry.details for file tracking */
 export interface CompactionDetails {
     readFiles: string[];
@@ -368,7 +368,7 @@ export interface CompactionPreparation {
     /** Preserved opaque compaction payload from the previous compaction, if any. */
     previousPreserveData?: Record<string, unknown>;
     /** File operations extracted from messagesToSummarize */
-    fileOps: FileOperations;
+    fileOps: snapcompact.FileOperations;
     /** Compaction settions from settings.jsonl	*/
     settings: CompactionSettings;
 }

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

@@ -3,13 +3,12 @@
  */
 import type { Message } from "@oh-my-pi/pi-ai";
 import { type Dialect } from "@oh-my-pi/pi-ai/dialect";
+import * as snapcompact from "@oh-my-pi/snapcompact";
 import type { AgentMessage } from "../types.js";
-export interface FileOperations {
-    read: Set<string>;
-    written: Set<string>;
-    edited: Set<string>;
-}
-export declare function createFileOps(): FileOperations;
+/** @deprecated Import these from `@oh-my-pi/snapcompact`. */
+export { computeFileLists, createFileOps, type FileOperations, isUrlSchemePath, upsertFileOperations, } from "@oh-my-pi/snapcompact";
+/** @deprecated Use `upsertFileOperations("", readFiles, modifiedFiles, readSet)` from `@oh-my-pi/snapcompact`. */
+export declare function formatFileOperations(readFiles: string[], modifiedFiles: string[], readSet?: ReadonlySet<string>): string;
 /** Error text for a summarization call that hit its output limit (`stopReason: "length"`): partial text is never used. */
 export declare function incompleteOutputError(prefix: string): string;
 /**
@@ -33,25 +32,10 @@ export declare function stripReadSelector(path: string): string;
  * than its plain lines: verbatim `raw` bytes or the merge `conflicts` view.
  */
 export declare function isAlternateFormReadSelector(sel: string): boolean;
-/**
- * Whether `path` references a `scheme://` URL (internal URI or web URL) rather
- * than a filesystem path that belongs in the compaction `<files>` summary.
- */
-export declare function isUrlSchemePath(path: string): boolean;
 /**
  * Extract file operations from tool calls in an assistant message.
  */
-export declare function extractFileOpsFromMessage(message: AgentMessage, fileOps: FileOperations): void;
-/**
- * Compute final file lists from file operations.
- * Returns readFiles (files only read, not modified) and modifiedFiles.
- */
-export declare function computeFileLists(fileOps: FileOperations): {
-    readFiles: string[];
-    modifiedFiles: string[];
-};
-export declare function formatFileOperations(readFiles: string[], modifiedFiles: string[], readSet?: ReadonlySet<string>): string;
-export declare function upsertFileOperations(summary: string, readFiles: string[], modifiedFiles: string[], readSet?: ReadonlySet<string>): string;
+export declare function extractFileOpsFromMessage(message: AgentMessage, fileOps: snapcompact.FileOperations): void;
 /**
  * Truncate tool results to the same representation used in summarization prompts.
  */

package/dist/types/telemetry.d.ts

@@ -558,7 +558,9 @@ export interface InstrumentedChatSpanOptions {
  * Short-circuits when `telemetry` is `undefined` so cost / overhead stays at
  * zero for installations without an OTEL SDK.
  */
-export declare function instrumentedCompleteSimple<TApi extends Api>(model: Model<TApi>, ctx: Context, options: SimpleStreamOptions, span: InstrumentedChatSpanOptions): Promise<AssistantMessage>;
+export declare function instrumentedCompleteSimple<TApi extends Api>(model: Model<TApi>, ctx: Context, options: SimpleStreamOptions & {
+    onAttempt?: (message: AssistantMessage) => void;
+}, span: InstrumentedChatSpanOptions): Promise<AssistantMessage>;
 /**
  * Start an `execute_tool` span representing one tool invocation. Parented
  * under the supplied `invoke_agent` span by default — pass `parent` to

package/dist/types/tokenizer.d.ts

@@ -10,6 +10,7 @@ type TokenizerModel = Pick<Model, "tokenizer"> & snapcompact.ShapeTarget & {
     compat?: Model["compat"];
     thinking?: Model["thinking"];
     reasoning?: boolean;
+    requestModelId?: string;
 };
 /** Identity of the reader whose replayed reasoning a {@link Tokenizer} counts; equal keys count it alike. */
 export declare function reasoningReplayKey(model: TokenizerModel | null | undefined): string;
@@ -24,13 +25,12 @@ export interface TokenizerOptions {
     nativeHistoryReplay?: boolean;
 }
 /**
- * `strict` always tries an exact native count (the catalog-resolved tokenizer
- * when known, o200k_base otherwise), falling back to the byte upper bound when
- * the loaded addon does not recognize that encoding. `approximate` and
- * `upperbound` prefer the same exact count for known tokenizer families or
- * when `PI_TOKENIZER_ACCURATE=1` is set; otherwise they use a cheap heuristic:
- * `approximate` a bytes/4 guess, `upperbound` the raw byte length (never
- * undercounts).
+ * Every mode counts with the native tokenizer: the catalog-resolved family
+ * when known, o200k_base otherwise. They differ only in the fallback when the
+ * loaded addon does not recognize that encoding: `strict` and `upperbound`
+ * the raw byte length (never undercounts), `approximate` a bytes/4 guess.
+ * Tests (`NODE_ENV=test`) skip the native count outside `strict` and use that
+ * fallback.
  */
 export type TokenCountMode = "strict" | "approximate" | "upperbound";
 /** Options for {@link Tokenizer.countMessage} / {@link Tokenizer.countMessages}. */
@@ -69,8 +69,8 @@ export interface TokenBudgetCheck {
  * when the model's encoding, image or thinking-replay pricing, replay
  * identity or native-history replay state changes); one-shot flows construct
  * their own for the model that will be billed. Known tokenizer families use
- * exact native counts; unknown models keep the fast byte estimate (or o200k
- * when `PI_TOKENIZER_ACCURATE=1`).
+ * exact native counts; other models are counted in o200k_base, which bills
+ * unknown readers closer than a bytes/4 guess.
  */
 export declare class Tokenizer {
     #private;

package/dist/types/types.d.ts

@@ -16,6 +16,21 @@ export interface QueuedMessagePreparation {
 export type QueuedMessageQueue = "steering" | "followUp";
 /** Prepare an exclusively claimed batch. Undefined delivers unchanged; the signal also aborts when the claim is cancelled. */
 export type PrepareQueuedMessages = (messages: readonly AgentMessage[], signal: AbortSignal, queue: QueuedMessageQueue) => QueuedMessagePreparation | undefined | Promise<QueuedMessagePreparation | undefined>;
+/**
+ * Synchronous arbiter over queued messages leaving a queue for delivery, for a
+ * queue whose messages someone else may withdraw concurrently (a session homed
+ * on another thread whose view pops them).
+ */
+export interface QueuedMessageGate {
+    /**
+     * Called with the batch about to be removed from `queue` for delivery; returns
+     * the candidates that must be dropped from the queue instead. The others are
+     * claimed for delivery.
+     */
+    claim(queue: QueuedMessageQueue, candidates: readonly AgentMessage[]): readonly AgentMessage[];
+    /** Called with claimed messages that left delivery undelivered (requeued, withdrawn, or cancelled). */
+    release(messages: readonly AgentMessage[]): void;
+}
 /** Called once an aside has been inserted into the agent's live context. */
 export declare const ASIDE_MESSAGE_COMMIT: unique symbol;
 /** Symbol-keyed handoff for one finalized, tool-owned stream speculation session. */
@@ -218,6 +233,8 @@ export interface AgentLoopConfig extends SimpleStreamOptions {
      * never consumes the queue.
      */
     getSteeringMessages?: (signal?: AbortSignal) => Promise<AgentMessage[]>;
+    /** Whether input is still owned by a queue and must be restored if a model call is aborted before it starts. */
+    isUndeliveredQueuedMessage?: (message: AgentMessage) => boolean;
     /**
      * Peeks whether steering messages are queued, without consuming them.
      *
@@ -390,6 +407,8 @@ export interface AgentLoopConfig extends SimpleStreamOptions {
      * then strips from arguments before executing tools.
      */
     intentTracing?: boolean;
+    /** Schema description of the injected intent field; `PI_INTENT_DESC` overrides it. Default `concise intent`. */
+    intentDescription?: string;
     /**
      * Strip tool descriptions (top-level + nested schema annotations) from the
      * provider-bound tool specs. Use when the full catalog is rendered into the

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-agent-core",
-	"version": "18.15.0",
+	"version": "18.17.0",
 	"description": "General-purpose agent with transport abstraction, state management, and attachment support",
 	"homepage": "https://omp.sh",
 	"author": {
@@ -31,25 +31,25 @@
 	"types": "./dist/types/index.d.ts",
 	"scripts": {
 		"check": "oxlint . && oxfmt --check --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts' && bun run check:types",
-		"check:types": "tsgo -p tsconfig.json --noEmit",
+		"check:types": "bun check --no-script -p tsconfig.json",
 		"lint": "oxlint .",
 		"test": "bun test --parallel",
 		"fix": "oxlint --fix --fix-suggestions . && bun run fmt",
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-ai": "18.15.0",
-		"@oh-my-pi/pi-catalog": "18.15.0",
-		"@oh-my-pi/pi-natives": "18.15.0",
-		"@oh-my-pi/pi-utils": "18.15.0",
-		"@oh-my-pi/pi-wire": "18.15.0",
-		"@oh-my-pi/snapcompact": "18.15.0",
+		"@oh-my-pi/pi-ai": "18.17.0",
+		"@oh-my-pi/pi-catalog": "18.17.0",
+		"@oh-my-pi/pi-natives": "18.17.0",
+		"@oh-my-pi/pi-utils": "18.17.0",
+		"@oh-my-pi/pi-wire": "18.17.0",
+		"@oh-my-pi/snapcompact": "18.17.0",
 		"@opentelemetry/api": "^1.9.1"
 	},
 	"devDependencies": {
-		"@oh-my-pi/omptype": "18.15.0",
-		"@opentelemetry/context-async-hooks": "^2.9.0",
-		"@opentelemetry/sdk-trace-base": "^2.9.0",
+		"@oh-my-pi/omptype": "18.17.0",
+		"@opentelemetry/context-async-hooks": "2.9.0",
+		"@opentelemetry/sdk-trace-base": "2.9.0",
 		"@types/bun": "^1.3.14"
 	},
 	"engines": {

package/src/agent-loop.ts

@@ -53,7 +53,7 @@ import {
 	signalListLabel,
 } from "@oh-my-pi/pi-ai/utils/harmony-leak";
 import { isDsmlLeakRecoveryTarget, removeDsmlToolMarkupLeak } from "@oh-my-pi/pi-ai/utils/dsml-leak";
-import { cloneJsonTree, logger, sanitizeText, structuredCloneJSON } from "@oh-my-pi/pi-utils";
+import { cloneJsonTree, logger, sanitizeText, structuredCloneJSON, toError } from "@oh-my-pi/pi-utils";
 import { INTENT_FIELD } from "@oh-my-pi/pi-wire";
 import { LiveSteeringChannel } from "./live-steering";
 import { agentPauseGate } from "./pause";
@@ -943,7 +943,7 @@ export function normalizeMessagesForProvider(
 	});
 }
 
-/** Schema description of the injected `i` field; `PI_INTENT_DESC` replaces it. */
+/** Schema description of the injected `i` field when neither `PI_INTENT_DESC` nor the caller sets one. */
 const DEFAULT_INTENT_FIELD_DESCRIPTION = "concise intent";
 const INTENT_SCHEMA_UNION_KEYS = ["anyOf", "oneOf"] as const;
 
@@ -954,26 +954,30 @@ const INTENT_SCHEMA_UNION_KEYS = ["anyOf", "oneOf"] as const;
 // the whole catalog per request). The injected object is shared across
 // requests — the same profile as the intent-off path, where parameters IS the
 // shared memoized wire schema (see schema-immutability.test.ts). One stamp
-// key per (mode, describeIntent) variant; index 0 = bare, 1 = described.
-const INTENT_STAMPS = {
-	require: [Symbol("intent:require"), Symbol("intent:require:described")],
-	optional: [Symbol("intent:optional"), Symbol("intent:optional:described")],
-} as const;
+// key per (mode, description) variant, "" keying the bare one: agents in one
+// process may describe `i` differently over the same shared tool schemas.
+const INTENT_STAMPS = { require: new Map<string, symbol>(), optional: new Map<string, symbol>() } as const;
 
 function memoizedInjectIntentIntoSchema(
 	schema: Record<string, unknown>,
 	mode: "require" | "optional",
-	describeIntent: boolean,
+	description: string | undefined,
 ): unknown {
-	return stamp(schema, INTENT_STAMPS[mode][describeIntent ? 1 : 0], host =>
-		injectIntentIntoSchema(host, mode, describeIntent),
-	);
+	const stamps = INTENT_STAMPS[mode];
+	const variant = description ?? "";
+	let key = stamps.get(variant);
+	if (!key) {
+		key = Symbol(`intent:${mode}`);
+		stamps.set(variant, key);
+	}
+	return stamp(schema, key, host => injectIntentIntoSchema(host, mode, description));
 }
 
+/** `schema` with the `i` field first (and required in `require` mode); `description` unset injects it bare. */
 function injectIntentIntoSchema(
 	schema: unknown,
-	mode: "require" | "optional" = "require",
-	describeIntent = true,
+	mode: "require" | "optional",
+	description: string | undefined,
 ): unknown {
 	if (!schema || typeof schema !== "object" || Array.isArray(schema)) return schema;
 	const schemaRecord = schema as Record<string, unknown>;
@@ -996,7 +1000,7 @@ function injectIntentIntoSchema(
 			if (!Array.isArray(variants)) continue;
 			return {
 				...schemaRecord,
-				[key]: variants.map(variant => injectIntentIntoSchema(variant, mode, describeIntent)),
+				[key]: variants.map(variant => injectIntentIntoSchema(variant, mode, description)),
 			};
 		}
 	}
@@ -1020,9 +1024,7 @@ function injectIntentIntoSchema(
 	return {
 		...schemaRecord,
 		properties: {
-			[INTENT_FIELD]: describeIntent
-				? { type: "string", description: Bun.env.PI_INTENT_DESC || DEFAULT_INTENT_FIELD_DESCRIPTION }
-				: { type: "string" },
+			[INTENT_FIELD]: description === undefined ? { type: "string" } : { type: "string", description },
 			...properties,
 		},
 		...(mode === "require" ? { required: [...required, INTENT_FIELD] } : {}),
@@ -1032,6 +1034,8 @@ function injectIntentIntoSchema(
 export interface NormalizeToolsOptions {
 	/** Inject the `i` intent field into tool schemas (subject to `PI_NO_INTENT`). */
 	injectIntent: boolean;
+	/** Schema description of the injected `i` field; `PI_INTENT_DESC` overrides it. Default `concise intent`. */
+	intentDescription?: string;
 	/** Strip descriptions from the wire specs when the catalog rides in the system prompt. */
 	pruneDescriptions?: boolean;
 }
@@ -1039,6 +1043,7 @@ export interface NormalizeToolsOptions {
 export function normalizeTools(tools: AgentContext["tools"], options: NormalizeToolsOptions): Context["tools"] {
 	const pruneDescriptions = options.pruneDescriptions === true;
 	const injectIntent = options.injectIntent && Bun.env.PI_NO_INTENT !== "1";
+	const intentDescription = Bun.env.PI_INTENT_DESC || options.intentDescription || DEFAULT_INTENT_FIELD_DESCRIPTION;
 	return tools?.map(t => {
 		const intentMode = resolveIntentMode(t.intent);
 		const doInjectIntent =
@@ -1047,17 +1052,19 @@ export function normalizeTools(tools: AgentContext["tools"], options: NormalizeT
 		// specs without their descriptions (top-level + nested schema annotations)
 		// so they are not duplicated on the wire. Strip the STABLE wire schema (the
 		// memoized `stripSchemaDescriptions` result is reused across requests), then
-		// re-inject `i` (without its hint, which `describeIntent: false` omits) so
+		// re-inject `i` (without its hint, which an unset description omits) so
 		// intent tracing keeps the field while no descriptions ride the wire.
 		if (pruneDescriptions) {
 			const stripped = stripSchemaDescriptions(toolWireSchema(t));
 			const parameters = (
-				doInjectIntent ? memoizedInjectIntentIntoSchema(stripped, intentMode, false) : stripped
+				doInjectIntent ? memoizedInjectIntentIntoSchema(stripped, intentMode, undefined) : stripped
 			) as TSchema;
 			return { ...t, parameters, description: "" };
 		}
 		const wire = toolWireSchema(t);
-		const parameters = (doInjectIntent ? memoizedInjectIntentIntoSchema(wire, intentMode, true) : wire) as TSchema;
+		const parameters = (
+			doInjectIntent ? memoizedInjectIntentIntoSchema(wire, intentMode, intentDescription) : wire
+		) as TSchema;
 		const description = t.description ?? "";
 		const examplesBlock = renderToolExamples({ ...t, parameters }, doInjectIntent ? INTENT_FIELD : undefined);
 		const finalDescription = examplesBlock ? `${description}\n\n${examplesBlock}` : description;
@@ -1188,7 +1195,7 @@ function resolveAsides(entries: AsideMessage[] | undefined): AgentMessage[] {
 			if (message) out.push(message);
 		}
 	} catch (error) {
-		discardAsides(out, error instanceof Error ? error : new Error(String(error)));
+		discardAsides(out, toError(error));
 		throw error;
 	}
 	return out;
@@ -1240,6 +1247,25 @@ async function runLoopBody(
 	// `liveAccepted` reached the model inside it, `liveDeferred` did not.
 	let liveAccepted: AgentMessage[] = [];
 	let liveDeferred: AgentMessage[] = [];
+	const endAbortedBeforeModel = async (messages: AgentMessage[], turnOpen: boolean): Promise<boolean> => {
+		if (!signal?.aborted || !config.isUndeliveredQueuedMessage) return false;
+		const undelivered = new Set(messages.filter(message => config.isUndeliveredQueuedMessage?.(message)));
+		for (const list of [currentContext.messages, newMessages]) {
+			for (let i = list.length - 1; i >= 0; i--) {
+				if (undelivered.has(list[i])) list.splice(i, 1);
+			}
+		}
+		if (!turnOpen) stream.push({ type: "turn_start" });
+		emitInputMessages(
+			stream,
+			messages.filter(message => !undelivered.has(message)),
+		);
+		const aborted = emitAbortedAssistantMessage(null, false, new Set(), currentContext, config, stream, signal);
+		newMessages.push(aborted);
+		await emitTurnEnd(stream, currentContext, aborted, [], config, signal, { willContinue: false });
+		endAgentStream(stream, newMessages, telemetry, stepCounter.count);
+		return true;
+	};
 	try {
 		let messagesToEmit = [...initialMessages];
 		if (isDeadlineExceeded(config.deadline)) {
@@ -1253,6 +1279,7 @@ async function runLoopBody(
 		try {
 			pendingMessages = signal?.aborted ? [] : (await config.getSteeringMessages?.(signal)) || [];
 		} catch (error) {
+			if (signal?.aborted && (await endAbortedBeforeModel(messagesToEmit, false))) return;
 			stream.push({ type: "turn_start" });
 			emitInputMessages(stream, messagesToEmit);
 			throw error;
@@ -1351,10 +1378,19 @@ async function runLoopBody(
 
 				let preparedProviderCall: PreparedProviderCall;
 				let gateResult: AgentPreModelCallResult;
+				const emitTurnInputs = () => {
+					emitInputMessages(
+						stream,
+						signal?.aborted
+							? turnMessages.filter(message => !config.isUndeliveredQueuedMessage?.(message))
+							: turnMessages,
+					);
+				};
 				try {
 					if (config.syncContextBeforeModelCall) {
 						await config.syncContextBeforeModelCall(currentContext, signal);
 					}
+					if (signal?.aborted && (await endAbortedBeforeModel(turnMessages, turnOpen))) return;
 
 					if (!directiveResolvedForTurn) {
 						const directive = signal?.aborted ? undefined : config.getToolChoice?.();
@@ -1383,16 +1419,19 @@ async function runLoopBody(
 					}
 
 					preparedProviderCall = await prepareProviderCall(currentContext, config, signal);
+					if (signal?.aborted && (await endAbortedBeforeModel(turnMessages, turnOpen))) return;
 					preparedProviderCall.liveSteering = openLiveSteering(config, signal, preparedProviderCall);
 					gateResult = (await config.beforeModelCall?.(preparedProviderCall.context, signal)) || undefined;
 				} catch (error) {
+					if (signal?.aborted && (await endAbortedBeforeModel(turnMessages, turnOpen))) return;
 					if (!turnOpen) {
 						stream.push({ type: "turn_start" });
-						emitInputMessages(stream, turnMessages);
+						emitTurnInputs();
 						turnOpen = true;
 					}
 					throw error;
 				}
+				if (signal?.aborted && (await endAbortedBeforeModel(turnMessages, turnOpen))) return;
 				if (config.beforeModelCall && signal?.aborted) {
 					gateResult = { stop: true };
 				}
@@ -1436,13 +1475,13 @@ async function runLoopBody(
 
 				if (!turnOpen) {
 					stream.push({ type: "turn_start" });
-					emitInputMessages(stream, turnMessages);
 					turnOpen = true;
 				}
 
 				// Stream assistant response
 				let recovered: HarmonyRecoveredToolCall | undefined;
 				let message: AssistantMessage;
+				let inputsEmitted = false;
 				try {
 					if (agentPauseGate.paused) await waitForProcessPause(config, signal);
 					message = await streamAssistantResponse(
@@ -1458,6 +1497,11 @@ async function runLoopBody(
 						hostToolChoice,
 						softRequirementState.forcedToolChoice,
 						preparedProviderCall,
+						() => {
+							if (config.isUndeliveredQueuedMessage) signal?.throwIfAborted();
+							emitTurnInputs();
+							inputsEmitted = true;
+						},
 						message => {
 							const finalToolCalls = message.content.filter(
 								(content): content is Extract<AssistantMessage["content"][number], { type: "toolCall" }> =>
@@ -1484,6 +1528,10 @@ async function runLoopBody(
 					harmonyRetryAttempt = 0;
 					harmonyTruncateResumeCount = 0;
 				} catch (err) {
+					if (!inputsEmitted) {
+						if (signal?.aborted && (await endAbortedBeforeModel(turnMessages, turnOpen))) return;
+						emitTurnInputs();
+					}
 					if (!(err instanceof HarmonyLeakInterruption)) throw err;
 					if (err.recovered) {
 						if (harmonyTruncateResumeCount >= 2) {
@@ -1958,6 +2006,7 @@ async function prepareProviderCall(
 		config.appendOnlyContext.syncMessages(normalizedMessages);
 		llmContext = config.appendOnlyContext.build(context, {
 			intentTracing: !!config.intentTracing,
+			intentDescription: config.intentDescription,
 			pruneToolDescriptions,
 		});
 	} else {
@@ -1966,6 +2015,7 @@ async function prepareProviderCall(
 			messages: normalizedMessages,
 			tools: normalizeTools(context.tools, {
 				injectIntent: !!config.intentTracing,
+				intentDescription: config.intentDescription,
 				pruneDescriptions: pruneToolDescriptions,
 			}),
 		};
@@ -2012,6 +2062,7 @@ async function streamAssistantResponse(
 	hostToolChoice?: ToolChoice,
 	forcedToolChoice?: ToolChoice,
 	prepared?: PreparedProviderCall,
+	onProviderStart?: () => void,
 	canDispatchFinalToolCalls?: (message: AssistantMessage) => boolean,
 ): Promise<AssistantMessage> {
 	const providerCall = prepared ?? (await prepareProviderCall(context, config, signal));
@@ -2156,6 +2207,7 @@ async function streamAssistantResponse(
 
 	try {
 		return await runInActiveSpan(chatSpan, async () => {
+			onProviderStart?.();
 			let response = await streamFunction(model, llmContext, {
 				...config,
 				apiKey,