@oh-my-pi/pi-coding-agent 16.0.4 → 16.0.6

package/src/modes/theme/theme.ts

@@ -11,9 +11,9 @@ import {
 } from "@oh-my-pi/pi-natives";
 import type { EditorTheme, MarkdownTheme, SelectListTheme, SettingsListTheme, SymbolTheme } from "@oh-my-pi/pi-tui";
 import { adjustHsv, colorLuma, getCustomThemesDir, isEnoent, logger, relativeLuminance } from "@oh-my-pi/pi-utils";
+import { type } from "arktype";
 import chalk from "chalk";
 import { LRUCache } from "lru-cache/raw";
-import { z } from "zod/v4";
 // Embed theme JSON files at build time
 import darkThemeJson from "./dark.json" with { type: "json" };
 import { defaultThemes } from "./defaults";
@@ -972,125 +972,117 @@ function normalizeSpinnerFramesOverride(
 // Types & Schema
 // ============================================================================
 
-const colorValueSchema = z.union([
-	z.string(), // hex "#ff0000", var ref "primary", or empty ""
-	z.number().int().min(0).max(255), // 256-color index
-]);
-
-type ColorValue = z.infer<typeof colorValueSchema>;
-
-const THEME_COLOR_KEYS = [
-	"accent",
-	"border",
-	"borderAccent",
-	"borderMuted",
-	"success",
-	"error",
-	"warning",
-	"muted",
-	"dim",
-	"text",
-	"thinkingText",
-	"selectedBg",
-	"userMessageBg",
-	"userMessageText",
-	"customMessageBg",
-	"customMessageText",
-	"customMessageLabel",
-	"toolPendingBg",
-	"toolSuccessBg",
-	"toolErrorBg",
-	"toolTitle",
-	"toolOutput",
-	"mdHeading",
-	"mdLink",
-	"mdLinkUrl",
-	"mdCode",
-	"mdCodeBlock",
-	"mdCodeBlockBorder",
-	"mdQuote",
-	"mdQuoteBorder",
-	"mdHr",
-	"mdListBullet",
-	"toolDiffAdded",
-	"toolDiffRemoved",
-	"toolDiffContext",
-	"syntaxComment",
-	"syntaxKeyword",
-	"syntaxFunction",
-	"syntaxVariable",
-	"syntaxString",
-	"syntaxNumber",
-	"syntaxType",
-	"syntaxOperator",
-	"syntaxPunctuation",
-	"thinkingOff",
-	"thinkingMinimal",
-	"thinkingLow",
-	"thinkingMedium",
-	"thinkingHigh",
-	"thinkingXhigh",
-	"bashMode",
-	"pythonMode",
-	"statusLineBg",
-	"statusLineSep",
-	"statusLineModel",
-	"statusLinePath",
-	"statusLineGitClean",
-	"statusLineGitDirty",
-	"statusLineContext",
-	"statusLineSpend",
-	"statusLineStaged",
-	"statusLineDirty",
-	"statusLineUntracked",
-	"statusLineOutput",
-	"statusLineCost",
-	"statusLineSubagents",
-] as const;
-
-const themeColorsSchema = z.object(
-	Object.fromEntries(THEME_COLOR_KEYS.map(key => [key, colorValueSchema])) as unknown as {
-		[K in (typeof THEME_COLOR_KEYS)[number]]: typeof colorValueSchema;
-	},
-);
-
-const spinnerFramesArraySchema = z.array(z.string().min(1)).min(1);
-const spinnerFramesSchema = z.union([
-	spinnerFramesArraySchema,
-	z
-		.object({
-			status: spinnerFramesArraySchema.optional(),
-			activity: spinnerFramesArraySchema.optional(),
-		})
-		.refine(value => value.status !== undefined || value.activity !== undefined, {
-			message: "spinnerFrames object must define `status` and/or `activity`",
-		}),
-]);
-
-const symbolPresetSchema = z.enum(["unicode", "nerd", "ascii"]);
-
-const themeJsonSchema = z.object({
-	$schema: z.string().optional(),
-	name: z.string(),
-	vars: z.record(z.string(), colorValueSchema).optional(),
+type ColorValue = string | number;
+
+const themeColorsSchema = type({
+	accent: "string | number",
+	border: "string | number",
+	borderAccent: "string | number",
+	borderMuted: "string | number",
+	success: "string | number",
+	error: "string | number",
+	warning: "string | number",
+	muted: "string | number",
+	dim: "string | number",
+	text: "string | number",
+	thinkingText: "string | number",
+	selectedBg: "string | number",
+	userMessageBg: "string | number",
+	userMessageText: "string | number",
+	customMessageBg: "string | number",
+	customMessageText: "string | number",
+	customMessageLabel: "string | number",
+	toolPendingBg: "string | number",
+	toolSuccessBg: "string | number",
+	toolErrorBg: "string | number",
+	toolTitle: "string | number",
+	toolOutput: "string | number",
+	mdHeading: "string | number",
+	mdLink: "string | number",
+	mdLinkUrl: "string | number",
+	mdCode: "string | number",
+	mdCodeBlock: "string | number",
+	mdCodeBlockBorder: "string | number",
+	mdQuote: "string | number",
+	mdQuoteBorder: "string | number",
+	mdHr: "string | number",
+	mdListBullet: "string | number",
+	toolDiffAdded: "string | number",
+	toolDiffRemoved: "string | number",
+	toolDiffContext: "string | number",
+	syntaxComment: "string | number",
+	syntaxKeyword: "string | number",
+	syntaxFunction: "string | number",
+	syntaxVariable: "string | number",
+	syntaxString: "string | number",
+	syntaxNumber: "string | number",
+	syntaxType: "string | number",
+	syntaxOperator: "string | number",
+	syntaxPunctuation: "string | number",
+	thinkingOff: "string | number",
+	thinkingMinimal: "string | number",
+	thinkingLow: "string | number",
+	thinkingMedium: "string | number",
+	thinkingHigh: "string | number",
+	thinkingXhigh: "string | number",
+	bashMode: "string | number",
+	pythonMode: "string | number",
+	statusLineBg: "string | number",
+	statusLineSep: "string | number",
+	statusLineModel: "string | number",
+	statusLinePath: "string | number",
+	statusLineGitClean: "string | number",
+	statusLineGitDirty: "string | number",
+	statusLineContext: "string | number",
+	statusLineSpend: "string | number",
+	statusLineStaged: "string | number",
+	statusLineDirty: "string | number",
+	statusLineUntracked: "string | number",
+	statusLineOutput: "string | number",
+	statusLineCost: "string | number",
+	statusLineSubagents: "string | number",
+});
+const spinnerFramesSchema = type("unknown").narrow((value): value is SpinnerFramesOverride => {
+	if (Array.isArray(value)) {
+		return value.length >= 1 && value.every(item => typeof item === "string");
+	}
+	if (value && typeof value === "object") {
+		const obj = value as Record<string, unknown>;
+		const status = obj.status;
+		const activity = obj.activity;
+		if (status === undefined && activity === undefined) return false;
+		if (status !== undefined) {
+			if (!Array.isArray(status) || status.length < 1 || !status.every(item => typeof item === "string")) {
+				return false;
+			}
+		}
+		if (activity !== undefined) {
+			if (!Array.isArray(activity) || activity.length < 1 || !activity.every(item => typeof item === "string")) {
+				return false;
+			}
+		}
+		return true;
+	}
+	return false;
+});
+const themeJsonSchema = type({
+	"$schema?": "string",
+	name: "string",
+	"vars?": "Record<string, string | number>",
 	colors: themeColorsSchema,
-	export: z
-		.object({
-			pageBg: colorValueSchema.optional(),
-			cardBg: colorValueSchema.optional(),
-			infoBg: colorValueSchema.optional(),
-		})
-		.optional(),
-	symbols: z
-		.object({
-			preset: symbolPresetSchema.optional(),
-			overrides: z.record(z.string(), z.string()).optional(),
-			spinnerFrames: spinnerFramesSchema.optional(),
-		})
-		.optional(),
+	"export?": {
+		"pageBg?": "string | number",
+		"cardBg?": "string | number",
+		"infoBg?": "string | number",
+	},
+	"symbols?": {
+		"preset?": "'unicode' | 'nerd' | 'ascii'",
+		"overrides?": "Record<string, string>",
+		"spinnerFrames?": spinnerFramesSchema,
+	},
 });
 
-type ThemeJson = z.infer<typeof themeJsonSchema>;
+type ThemeJson = typeof themeJsonSchema.infer;
 
 export type ThemeColor =
 	| "accent"
@@ -1952,37 +1944,30 @@ async function loadThemeJson(name: string): Promise<ThemeJson> {
 	} catch (error) {
 		throw new Error(`Failed to parse theme ${name}: ${error}`);
 	}
-	const parsed = themeJsonSchema.safeParse(json);
-	if (!parsed.success) {
-		const missingColors: string[] = [];
-		const otherErrors: string[] = [];
-
-		for (const issue of parsed.error.issues) {
-			const parts = issue.path;
-			const colorKey = parts.length === 2 && parts[0] === "colors" && typeof parts[1] === "string" ? parts[1] : null;
-
-			if (colorKey && issue.code === "invalid_type" && (issue as { received?: unknown }).received === undefined) {
-				missingColors.push(colorKey);
-			} else {
-				const pathStr = parts.length === 0 ? "/" : `/${parts.map(String).join("/")}`;
-				otherErrors.push(`  - ${pathStr}: ${issue.message}`);
-			}
+	let parsed: ThemeJson;
+	try {
+		parsed = themeJsonSchema(json) as ThemeJson;
+		if (parsed instanceof type.errors) {
+			throw new Error(parsed.summary);
 		}
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		// Extract color key information if available
+		const missingColorMatch = errorMessage.match(/missing keys: (.+)/i);
+		const missingColors: string[] = missingColorMatch ? missingColorMatch[1].split(",").map(s => s.trim()) : [];
 
-		let errorMessage = `Invalid theme "${name}":\n`;
+		let fullErrorMessage = `Invalid theme "${name}":\n`;
 		if (missingColors.length > 0) {
-			errorMessage += `\nMissing required color tokens:\n`;
-			errorMessage += missingColors.map(c => `  - ${c}`).join("\n");
-			errorMessage += `\n\nPlease add these colors to your theme's "colors" object.`;
-			errorMessage += `\nSee the built-in themes (dark.json, light.json) for reference values.`;
-		}
-		if (otherErrors.length > 0) {
-			errorMessage += `\n\nOther errors:\n${otherErrors.join("\n")}`;
+			fullErrorMessage += `\nMissing required color tokens:\n`;
+			fullErrorMessage += missingColors.map(c => `  - ${c}`).join("\n");
+			fullErrorMessage += `\n\nPlease add these colors to your theme's "colors" object.`;
+			fullErrorMessage += `\nSee the built-in themes (dark.json, light.json) for reference values.`;
 		}
+		fullErrorMessage += `\n\nValidation error:\n  - ${errorMessage}`;
 
-		throw new Error(errorMessage);
+		throw new Error(fullErrorMessage);
 	}
-	return parsed.data;
+	return parsed;
 }
 
 interface CreateThemeOptions {
@@ -2302,8 +2287,13 @@ export function getColorBlindMode(): boolean {
 	return currentColorBlindMode;
 }
 
-export function onThemeChange(callback: () => void): void {
+export function onThemeChange(callback: () => void): () => void {
 	onThemeChangeCallback = callback;
+	return () => {
+		if (onThemeChangeCallback === callback) {
+			onThemeChangeCallback = undefined;
+		}
+	};
 }
 
 /**

package/src/modes/types.ts

@@ -339,6 +339,9 @@ export interface InteractiveModeContext {
 	handleTanCommand(work: string): Promise<void>;
 	hasActiveBtw(): boolean;
 	handleBtwEscape(): boolean;
+	handleBtwBranchKey(): Promise<boolean>;
+	canBranchBtw(): boolean;
+	handleBtwBranch(question: string, assistantMessage: AssistantMessage): Promise<void>;
 	handleOmfgCommand(complaint: string): Promise<void>;
 	hasActiveOmfg(): boolean;
 	handleOmfgEscape(): boolean;

package/src/modes/utils/context-usage.ts

@@ -1,8 +1,8 @@
+import { countTokens } from "@oh-my-pi/pi-agent-core";
 import type { CompactionSettings } from "@oh-my-pi/pi-agent-core/compaction";
 import { effectiveReserveTokens, estimateTokens, resolveThresholdTokens } from "@oh-my-pi/pi-agent-core/compaction";
-import type { Model } from "@oh-my-pi/pi-ai";
-import { isZodSchema, zodToWireSchema } from "@oh-my-pi/pi-ai/utils/schema";
-import { countTokens } from "@oh-my-pi/pi-natives";
+import type { Tool as AiTool, Model } from "@oh-my-pi/pi-ai";
+import { toolWireSchema } from "@oh-my-pi/pi-ai/utils/schema";
 import { formatNumber } from "@oh-my-pi/pi-utils";
 import type { Skill } from "../../extensibility/skills";
 import type { AgentSession } from "../../session/agent-session";
@@ -61,8 +61,12 @@ export function estimateToolSchemaTokens(
 	for (const tool of tools) {
 		fragments.push(tool.name, tool.description);
 		try {
-			const params = tool.parameters;
-			fragments.push(JSON.stringify((isZodSchema(params) ? zodToWireSchema(params) : params) ?? {}));
+			const wireTool: AiTool = {
+				name: tool.name,
+				description: tool.description,
+				parameters: tool.parameters as AiTool["parameters"],
+			};
+			fragments.push(JSON.stringify(toolWireSchema(wireTool) ?? {}));
 		} catch {
 			// Schema may contain functions or cycles; ignore.
 		}
@@ -94,7 +98,7 @@ export function computeNonMessageTokens(session: AgentSession): number {
  * the status-line fast path intentionally uses the equivalent collapsed total
  * in `computeNonMessageTokens`.
  */
-function computeNonMessageBreakdown(session: AgentSession): {
+export function computeNonMessageBreakdown(session: AgentSession): {
 	skillsTokens: number;
 	toolsTokens: number;
 	systemContextTokens: number;
@@ -119,22 +123,37 @@ export function computeContextBreakdown(
 	const model = session.model;
 	const contextWindow = model?.contextWindow ?? 0;
 
+	const breakdown = typeof session.getContextBreakdown === "function" ? session.getContextBreakdown() : undefined;
+
 	let messagesTokens = 0;
-	const convo = session.messages;
-	if (convo) {
-		for (const message of convo) {
-			messagesTokens += estimateTokens(message);
+	let skillsTokens = 0;
+	let toolsTokens = 0;
+	let systemContextTokens = 0;
+	let systemPromptTokens = 0;
+	let usedTokens = 0;
+
+	if (breakdown) {
+		messagesTokens = breakdown.messagesTokens;
+		skillsTokens = breakdown.skillsTokens;
+		toolsTokens = breakdown.systemToolsTokens;
+		systemContextTokens = breakdown.systemContextTokens;
+		systemPromptTokens = breakdown.systemPromptTokens;
+		usedTokens = breakdown.usedTokens;
+	} else {
+		const convo = session.messages;
+		if (convo) {
+			for (const message of convo) {
+				messagesTokens += estimateTokens(message);
+			}
 		}
+		const nonMessage = computeNonMessageBreakdown(session);
+		skillsTokens = nonMessage.skillsTokens;
+		toolsTokens = nonMessage.toolsTokens;
+		systemContextTokens = nonMessage.systemContextTokens;
+		systemPromptTokens = nonMessage.systemPromptTokens;
+		usedTokens = skillsTokens + toolsTokens + systemContextTokens + systemPromptTokens + messagesTokens;
 	}
 
-	// The rendered system prompt already contains the skill descriptions and the
-	// markdown tool descriptions. To present a non-overlapping breakdown:
-	//   System prompt = total system prompt text - skills section (tool descriptions stay)
-	//   Tools         = JSON tool schema sent separately on the wire
-	//   Skills        = the skill list embedded in the system prompt
-	//   Messages      = conversation messages
-	const { skillsTokens, toolsTokens, systemContextTokens, systemPromptTokens } = computeNonMessageBreakdown(session);
-
 	const categories: CategoryInfo[] = [
 		{ id: "systemPrompt", label: "System prompt", tokens: systemPromptTokens, color: "accent", glyph: CELL_FILLED },
 		{ id: "systemTools", label: "System tools", tokens: toolsTokens, color: "warning", glyph: CELL_FILLED },
@@ -155,8 +174,6 @@ export function computeContextBreakdown(
 		},
 	];
 
-	const usedTokens = categories.reduce((sum, c) => sum + c.tokens, 0);
-
 	let autoCompactBufferTokens = 0;
 	if (contextWindow > 0) {
 		const compactionSettings = session.settings.getGroup("compaction") as CompactionSettings;

package/src/modes/utils/hotkeys-markdown.ts

@@ -48,6 +48,7 @@ export function buildHotkeysMarkdown(bindings: HotkeysMarkdownBindings): string
 		`| \`${appKey(bindings, "app.tools.expand")}\` | Toggle tool output expansion |`,
 		`| \`${appKey(bindings, "app.thinking.toggle")}\` | Toggle thinking block visibility |`,
 		`| \`${appKey(bindings, "app.editor.external")}\` | Edit message in external editor |`,
+		`| \`${appKey(bindings, "app.retry")}\` | Retry last failed assistant turn |`,
 		`| \`${appKey(bindings, "app.clipboard.pasteImage")}\` | Paste image or text from clipboard |`,
 		"| Hold `Space` | Speech-to-text (push-to-talk): hold to record, release to transcribe |",
 		`| \`${appKey(bindings, "app.agents.hub")}\` / \`${appKey(bindings, "app.session.observe")}\` / double-tap \`←\` (empty editor) | Open the agent hub |`,

package/src/prompts/system/system-prompt.md

@@ -15,6 +15,7 @@ You are a helpful assistant the team trusts with load-bearing changes, operating
 - You are not alone in this repository. You SHOULD treat unexpected changes as the user's work and adapt.
 - In user-visible terminal prose and final chat, you MAY use LaTeX math delimiters (such as $ or $$) and LaTeX math commands (such as \text, \times) to format equations, as well as  (`\textcolor`, `\colorbox`, `\fcolorbox`) to colorize the output.
 - To show the user a diagram (flowchart, sequence, state, ER, etc.), you MAY emit a fenced ` ```mermaid ` code block in your final chat — the terminal renders Mermaid source as an ASCII diagram. Keep it for genuine structure/flow; prefer prose for trivial points.
+- When you need a visual separator between sections of prose / sections of code, you MUST use `─` (U+2500).
 
 TOOLS
 ===================================

package/src/prompts/tools/image-attachment-describe-system.md

@@ -0,0 +1,8 @@
+You are an image-analysis assistant. The user attached an image to a model that cannot see images, so your description is injected into that model's context in place of the image. The downstream model relies entirely on your text — it never sees the pixels.
+
+Core behavior:
+- Be faithful and evidence-first: distinguish direct observations from inferences.
+- Transcribe ALL visible text verbatim, preserving casing, punctuation, and layout order. Mark unreadable segments explicitly rather than guessing.
+- NEVER fabricate occluded, blurry, or uncertain details — say what is uncertain.
+- Be thorough but compact: prefer dense, information-rich prose over filler.
+- Do not add meta commentary, preambles ("This image shows…"), or closing remarks. Output only the description.

package/src/prompts/tools/image-attachment-describe.md

@@ -0,0 +1,10 @@
+Describe this image in enough detail that a model which cannot see it can reason about its content.
+
+Cover, where present:
+- The overall scene, subject, and what is happening.
+- People, objects, and their relationships, positions, colors, and counts.
+- All visible text, transcribed verbatim (OCR).
+- UI/screenshot elements: labels, buttons, inputs, states, errors, highlighted or disabled controls.
+- Diagrams, charts, tables: structure, axes, series, and the values they encode.
+
+Flag anything ambiguous or unreadable. Output the description as plain prose only.

package/src/sdk.ts

@@ -21,6 +21,7 @@ import {
 	getOpenAICodexTransportDetails,
 	prewarmOpenAICodexResponses,
 } from "@oh-my-pi/pi-ai/providers/openai-codex-responses";
+import { FALLBACK_DIALECT, preferredDialect } from "@oh-my-pi/pi-catalog/identity";
 import type { Component } from "@oh-my-pi/pi-tui";
 import {
 	$env,
@@ -40,7 +41,6 @@ import { AutoLearnController, buildAutoLearnInstructions } from "./autolearn/con
 import { loadCapability } from "./capability";
 import { type Rule, ruleCapability, setActiveRules } from "./capability/rule";
 import { bucketRules } from "./capability/rule-buckets";
-import { createApiKeyResolver } from "./config/api-key-resolver";
 import { shouldEnableAppendOnlyContext } from "./config/append-only-context-mode";
 import { ModelRegistry } from "./config/model-registry";
 import {
@@ -415,6 +415,8 @@ export interface CreateAgentSessionOptions {
 	providerSessionId?: string;
 	/** Optional provider-facing prompt cache key, distinct from request lineage. */
 	providerPromptCacheKey?: string;
+	/** Absolute wall-clock deadline in Unix epoch milliseconds. */
+	deadline?: number;
 
 	/** Custom tools to register (in addition to built-in tools). Accepts both CustomTool and ToolDefinition. */
 	customTools?: (CustomTool | ToolDefinition)[];
@@ -526,6 +528,11 @@ export interface CreateAgentSessionOptions {
 
 	/** Settings instance. Default: Settings.init({ cwd, agentDir }) */
 	settings?: Settings;
+	/**
+	 * Legacy alias for `settings`. Older Pi extensions pass SettingsManager.create(...)
+	 * through this field; accept it so their SDK calls keep the configured settings.
+	 */
+	settingsManager?: Settings | Promise<Settings>;
 
 	/** Whether UI is available (enables interactive tools like ask). Default: false */
 	hasUI?: boolean;
@@ -567,10 +574,15 @@ export type DialectFormat = "auto" | "native" | Dialect;
 
 export function resolveDialect(
 	format: DialectFormat,
-	model: Pick<Model, "supportsTools"> | undefined,
+	model: (Pick<Model, "supportsTools"> & Partial<Pick<Model, "id">>) | undefined,
 ): Dialect | undefined {
 	if (format === "native") return undefined;
-	if (format === "auto") return model?.supportsTools === false ? "glm" : undefined;
+	if (format === "auto") {
+		if (model?.supportsTools !== false) return undefined;
+		if (!model.id) return "glm";
+		const preferred = preferredDialect(model.id);
+		return preferred === FALLBACK_DIALECT ? "glm" : preferred;
+	}
 	return format;
 }
 
@@ -867,6 +879,10 @@ function isCustomTool(tool: CustomTool | ToolDefinition): tool is CustomTool {
 	return !(tool as any).__isToolDefinition;
 }
 
+function isLegacyBuiltinToolDefinition(tool: CustomTool | ToolDefinition): boolean {
+	return !isCustomTool(tool) && "__ompLegacyBuiltinTool" in tool && tool.__ompLegacyBuiltinTool === true;
+}
+
 const TOOL_DEFINITION_MARKER = Symbol("__isToolDefinition");
 
 /** Matches the truncation applied to per-server instructions inside `rebuildSystemPrompt`. */
@@ -1131,7 +1147,9 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			startupCredentialDisabledEvents.push(event);
 		}
 	});
-	const settings = options.settings ?? (await logger.time("settings", Settings.init, { cwd, agentDir }));
+	const settings = await (options.settings ??
+		options.settingsManager ??
+		logger.time("settings", Settings.init, { cwd, agentDir }));
 	logger.time("initializeWithSettings", initializeWithSettings, settings);
 	if (!options.modelRegistry) {
 		modelRegistry.refreshInBackground();
@@ -2001,12 +2019,13 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		const toolContextStore = new ToolContextStore(getSessionContext);
 
 		const registeredTools = extensionRunner.getAllRegisteredTools();
+		const sdkCustomTools = options.customTools?.filter(tool => !isLegacyBuiltinToolDefinition(tool)) ?? [];
 		const allCustomTools = [
 			...registeredTools,
-			...(options.customTools?.map(tool => {
+			...sdkCustomTools.map(tool => {
 				const definition = isCustomTool(tool) ? customToolToDefinition(tool) : tool;
 				return { definition, extensionPath: "<sdk>" };
-			}) ?? []),
+			}),
 		];
 		// `wrapToolWithMetaNotice` runs the centralized large-output → artifact spill.
 		// Built-in tools get it in `createTools`; extension, SDK-custom, image-gen,
@@ -2284,7 +2303,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 
 		// Custom tools and extension-registered tools are always included regardless of toolNames filter
 		const alwaysInclude: string[] = [
-			...(options.customTools?.map(t => (isCustomTool(t) ? t.name : t.name)) ?? []),
+			...sdkCustomTools.map(t => (isCustomTool(t) ? t.name : t.name)),
 			...registeredTools.filter(t => !t.definition.defaultInactive).map(t => t.definition.name),
 		];
 		for (const name of alwaysInclude) {
@@ -2458,6 +2477,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			onResponse,
 			sessionId: providerSessionId,
 			promptCacheKey: options.providerPromptCacheKey,
+			deadline: options.deadline,
 			transformContext,
 			transformProviderContext,
 			steeringMode: settings.get("steeringMode") ?? "one-at-a-time",
@@ -2475,28 +2495,21 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			kimiApiFormat: settings.get("providers.kimiApiFormat") ?? "anthropic",
 			preferWebsockets: preferOpenAICodexWebsockets,
 			getToolContext: tc => toolContextStore.getContext(tc),
-			getApiKey: async (provider, ctx) => {
-				// Read agent.sessionId at call time so credential selection stays aligned
-				// with metadataResolver after /new, fork, resume, or branch switches.
-				// Retry steps (ctx carries an auth error) drive the central a/b/c
-				// policy — force-refresh the same account, then rotate to a sibling —
-				// and may legitimately yield no key when every account is exhausted.
-				if (ctx?.error !== undefined) {
-					return createApiKeyResolver(modelRegistry, provider, { sessionId: agent.sessionId })(ctx);
-				}
-				const key = await modelRegistry.getApiKeyForProvider(provider, agent.sessionId);
-				if (!key) {
-					throw new Error(`No API key found for provider "${provider}"`);
-				}
-				return key;
-			},
+			getApiKey: requestModel => modelRegistry.resolver(requestModel, agent.sessionId),
 			streamFn: (streamModel, context, streamOptions) => {
 				const openrouterRoutingPreset = settings.get("providers.openrouterVariant");
 				const openrouterVariant =
 					openrouterRoutingPreset && openrouterRoutingPreset !== "default" ? openrouterRoutingPreset : undefined;
+				const antigravityEndpointMode = settings.get("providers.antigravityEndpoint");
 				return streamSimple(streamModel, context, {
 					...streamOptions,
 					openrouterVariant: streamOptions?.openrouterVariant ?? openrouterVariant,
+					antigravityEndpointMode: streamOptions?.antigravityEndpointMode ?? antigravityEndpointMode,
+					loopGuard: {
+						enabled: settings.get("model.loopGuard.enabled"),
+						checkAssistantContent: settings.get("model.loopGuard.checkAssistantContent"),
+						...streamOptions?.loopGuard,
+					},
 				});
 			},
 			cursorExecHandlers,