@oh-my-pi/pi-coding-agent 13.9.2 → 13.9.4

package/src/session/messages.ts

@@ -5,7 +5,14 @@
  * and provides a transformer to convert them to LLM-compatible messages.
  */
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
-import type { ImageContent, Message, MessageAttribution, TextContent, ToolResultMessage } from "@oh-my-pi/pi-ai";
+import type {
+	ImageContent,
+	Message,
+	MessageAttribution,
+	ProviderPayload,
+	TextContent,
+	ToolResultMessage,
+} from "@oh-my-pi/pi-ai";
 import { renderPromptTemplate } from "../config/prompt-templates";
 import branchSummaryContextPrompt from "../prompts/compaction/branch-summary-context.md" with { type: "text" };
 import compactionSummaryContextPrompt from "../prompts/compaction/compaction-summary-context.md" with { type: "text" };
@@ -106,6 +113,7 @@ export interface CompactionSummaryMessage {
 	summary: string;
 	shortSummary?: string;
 	tokensBefore: number;
+	providerPayload?: ProviderPayload;
 	timestamp: number;
 }
 
@@ -193,12 +201,14 @@ export function createCompactionSummaryMessage(
 	tokensBefore: number,
 	timestamp: string,
 	shortSummary?: string,
+	providerPayload?: ProviderPayload,
 ): CompactionSummaryMessage {
 	return {
 		role: "compactionSummary",
 		summary,
 		shortSummary,
 		tokensBefore,
+		providerPayload,
 		timestamp: new Date(timestamp).getTime(),
 	};
 }
@@ -289,6 +299,7 @@ export function convertToLlm(messages: AgentMessage[]): Message[] {
 							},
 						],
 						attribution: "agent",
+						providerPayload: m.providerPayload,
 						timestamp: m.timestamp,
 					};
 				case "fileMention": {

package/src/session/session-manager.ts

@@ -2,7 +2,15 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
-import type { ImageContent, Message, MessageAttribution, TextContent, Usage } from "@oh-my-pi/pi-ai";
+import type {
+	ImageContent,
+	Message,
+	MessageAttribution,
+	ProviderPayload,
+	ServiceTier,
+	TextContent,
+	Usage,
+} from "@oh-my-pi/pi-ai";
 import { getTerminalId } from "@oh-my-pi/pi-tui";
 import {
 	getBlobsDir,
@@ -59,7 +67,7 @@ export interface SessionMessageEntry extends SessionEntryBase {
 
 export interface ThinkingLevelChangeEntry extends SessionEntryBase {
 	type: "thinking_level_change";
-	thinkingLevel: string;
+	thinkingLevel?: string | null;
 }
 
 export interface ModelChangeEntry extends SessionEntryBase {
@@ -70,6 +78,11 @@ export interface ModelChangeEntry extends SessionEntryBase {
 	role?: string;
 }
 
+export interface ServiceTierChangeEntry extends SessionEntryBase {
+	type: "service_tier_change";
+	serviceTier: ServiceTier | null;
+}
+
 export interface CompactionEntry<T = unknown> extends SessionEntryBase {
 	type: "compaction";
 	summary: string;
@@ -173,6 +186,7 @@ export type SessionEntry =
 	| SessionMessageEntry
 	| ThinkingLevelChangeEntry
 	| ModelChangeEntry
+	| ServiceTierChangeEntry
 	| CompactionEntry
 	| BranchSummaryEntry
 	| CustomEntry
@@ -195,7 +209,8 @@ export interface SessionTreeNode {
 
 export interface SessionContext {
 	messages: AgentMessage[];
-	thinkingLevel: string;
+	thinkingLevel?: string;
+	serviceTier?: ServiceTier;
 	/** Model roles: { default: "provider/modelId", small: "provider/modelId", ... } */
 	models: Record<string, string>;
 	/** Names of TTSR rules that have been injected this session */
@@ -416,7 +431,14 @@ export function buildSessionContext(
 	let leaf: SessionEntry | undefined;
 	if (leafId === null) {
 		// Explicitly null - return no messages (navigated to before first entry)
-		return { messages: [], thinkingLevel: "off", models: {}, injectedTtsrRules: [], mode: "none" };
+		return {
+			messages: [],
+			thinkingLevel: "off",
+			serviceTier: undefined,
+			models: {},
+			injectedTtsrRules: [],
+			mode: "none",
+		};
 	}
 	if (leafId) {
 		leaf = byId.get(leafId);
@@ -427,7 +449,14 @@ export function buildSessionContext(
 	}
 
 	if (!leaf) {
-		return { messages: [], thinkingLevel: "off", models: {}, injectedTtsrRules: [], mode: "none" };
+		return {
+			messages: [],
+			thinkingLevel: "off",
+			serviceTier: undefined,
+			models: {},
+			injectedTtsrRules: [],
+			mode: "none",
+		};
 	}
 
 	// Walk from leaf to root, collecting path
@@ -439,7 +468,8 @@ export function buildSessionContext(
 	}
 
 	// Extract settings and find compaction
-	let thinkingLevel = "off";
+	let thinkingLevel: string | undefined = "off";
+	let serviceTier: ServiceTier | undefined;
 	const models: Record<string, string> = {};
 	let compaction: CompactionEntry | null = null;
 	const injectedTtsrRulesSet = new Set<string>();
@@ -448,13 +478,15 @@ export function buildSessionContext(
 
 	for (const entry of path) {
 		if (entry.type === "thinking_level_change") {
-			thinkingLevel = entry.thinkingLevel;
+			thinkingLevel = entry.thinkingLevel ?? "off";
 		} else if (entry.type === "model_change") {
 			// New format: { model: "provider/id", role?: string }
 			if (entry.model) {
 				const role = entry.role ?? "default";
 				models[role] = entry.model;
 			}
+		} else if (entry.type === "service_tier_change") {
+			serviceTier = entry.serviceTier ?? undefined;
 		} else if (entry.type === "message" && entry.message.role === "assistant") {
 			// Infer default model from assistant messages
 			models.default = `${entry.message.provider}/${entry.message.model}`;
@@ -500,6 +532,17 @@ export function buildSessionContext(
 	};
 
 	if (compaction) {
+		const remoteReplacementHistory = (() => {
+			const candidate = compaction.preserveData?.openaiRemoteCompaction;
+			if (!candidate || typeof candidate !== "object") return undefined;
+			const replacementHistory = (candidate as { replacementHistory?: unknown }).replacementHistory;
+			if (!Array.isArray(replacementHistory)) return undefined;
+			return replacementHistory as Array<Record<string, unknown>>;
+		})();
+		const providerPayload: ProviderPayload | undefined = remoteReplacementHistory
+			? { type: "openaiResponsesHistory", items: remoteReplacementHistory }
+			: undefined;
+
 		// Emit summary first
 		messages.push(
 			createCompactionSummaryMessage(
@@ -507,21 +550,24 @@ export function buildSessionContext(
 				compaction.tokensBefore,
 				compaction.timestamp,
 				compaction.shortSummary,
+				providerPayload,
 			),
 		);
 
 		// Find compaction index in path
 		const compactionIdx = path.findIndex(e => e.type === "compaction" && e.id === compaction.id);
 
-		// Emit kept messages (before compaction, starting from firstKeptEntryId)
-		let foundFirstKept = false;
-		for (let i = 0; i < compactionIdx; i++) {
-			const entry = path[i];
-			if (entry.id === compaction.firstKeptEntryId) {
-				foundFirstKept = true;
-			}
-			if (foundFirstKept) {
-				appendMessage(entry);
+		if (!remoteReplacementHistory) {
+			// Emit kept messages (before compaction, starting from firstKeptEntryId)
+			let foundFirstKept = false;
+			for (let i = 0; i < compactionIdx; i++) {
+				const entry = path[i];
+				if (entry.id === compaction.firstKeptEntryId) {
+					foundFirstKept = true;
+				}
+				if (foundFirstKept) {
+					appendMessage(entry);
+				}
 			}
 		}
 
@@ -537,7 +583,7 @@ export function buildSessionContext(
 		}
 	}
 
-	return { messages, thinkingLevel, models, injectedTtsrRules, mode, modeData };
+	return { messages, thinkingLevel, serviceTier, models, injectedTtsrRules, mode, modeData };
 }
 
 /**
@@ -1783,13 +1829,25 @@ export class SessionManager {
 	}
 
 	/** Append a thinking level change as child of current leaf, then advance leaf. Returns entry id. */
-	appendThinkingLevelChange(thinkingLevel: string): string {
+	appendThinkingLevelChange(thinkingLevel?: string): string {
 		const entry: ThinkingLevelChangeEntry = {
 			type: "thinking_level_change",
 			id: generateId(this.#byId),
 			parentId: this.#leafId,
 			timestamp: new Date().toISOString(),
-			thinkingLevel,
+			thinkingLevel: thinkingLevel ?? null,
+		};
+		this.#appendEntry(entry);
+		return entry.id;
+	}
+
+	appendServiceTierChange(serviceTier: ServiceTier | null): string {
+		const entry: ServiceTierChangeEntry = {
+			type: "service_tier_change",
+			id: generateId(this.#byId),
+			parentId: this.#leafId,
+			timestamp: new Date().toISOString(),
+			serviceTier,
 		};
 		this.#appendEntry(entry);
 		return entry.id;

package/src/slash-commands/builtin-registry.ts

@@ -3,6 +3,12 @@ import type { SettingPath, SettingValue } from "../config/settings";
 import { settings } from "../config/settings";
 import type { InteractiveModeContext } from "../modes/types";
 
+function refreshStatusLine(ctx: InteractiveModeContext): void {
+	ctx.statusLine.invalidate();
+	ctx.updateEditorTopBorder();
+	ctx.ui.requestRender();
+}
+
 /** Declarative subcommand definition for commands like /mcp. */
 export interface SubcommandDef {
 	name: string;
@@ -92,6 +98,48 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<BuiltinSlashCommandSpec> = [
 			runtime.ctx.editor.setText("");
 		},
 	},
+	{
+		name: "fast",
+		description: "Toggle fast mode (OpenAI service tier priority)",
+		subcommands: [
+			{ name: "on", description: "Enable fast mode" },
+			{ name: "off", description: "Disable fast mode" },
+			{ name: "status", description: "Show fast mode status" },
+		],
+		allowArgs: true,
+		handle: (command, runtime) => {
+			const arg = command.args.trim().toLowerCase();
+			if (!arg || arg === "toggle") {
+				const enabled = runtime.ctx.session.toggleFastMode();
+				refreshStatusLine(runtime.ctx);
+				runtime.ctx.showStatus(`Fast mode ${enabled ? "enabled" : "disabled"}.`);
+				runtime.ctx.editor.setText("");
+				return;
+			}
+			if (arg === "on") {
+				runtime.ctx.session.setFastMode(true);
+				refreshStatusLine(runtime.ctx);
+				runtime.ctx.showStatus("Fast mode enabled.");
+				runtime.ctx.editor.setText("");
+				return;
+			}
+			if (arg === "off") {
+				runtime.ctx.session.setFastMode(false);
+				refreshStatusLine(runtime.ctx);
+				runtime.ctx.showStatus("Fast mode disabled.");
+				runtime.ctx.editor.setText("");
+				return;
+			}
+			if (arg === "status") {
+				const enabled = runtime.ctx.session.isFastModeEnabled();
+				runtime.ctx.showStatus(`Fast mode is ${enabled ? "on" : "off"}.`);
+				runtime.ctx.editor.setText("");
+				return;
+			}
+			runtime.ctx.showStatus("Usage: /fast [on|off|status]");
+			runtime.ctx.editor.setText("");
+		},
+	},
 	{
 		name: "export",
 		description: "Export session to HTML file",

package/src/task/agents.ts

@@ -3,6 +3,7 @@
  *
  * Agents are embedded at build time via Bun's import with { type: "text" }.
  */
+import { Effort } from "@oh-my-pi/pi-ai";
 import { renderPromptTemplate } from "../config/prompt-templates";
 import { parseAgentFields } from "../discovery/helpers";
 import designerMd from "../prompts/agents/designer.md" with { type: "text" };
@@ -53,7 +54,7 @@ const EMBEDDED_AGENT_DEFS: EmbeddedAgentDef[] = [
 			description: "General-purpose subagent with full capabilities for delegated multi-step tasks",
 			spawns: "*",
 			model: "default",
-			thinkingLevel: "medium",
+			thinkingLevel: Effort.Medium,
 		},
 		template: taskMd,
 	},
@@ -63,7 +64,7 @@ const EMBEDDED_AGENT_DEFS: EmbeddedAgentDef[] = [
 			name: "quick_task",
 			description: "Low-reasoning agent for strictly mechanical updates or data collection only",
 			model: "pi/smol",
-			thinkingLevel: "minimal",
+			thinkingLevel: Effort.Minimal,
 		},
 		template: taskMd,
 	},

package/src/task/executor.ts

@@ -4,8 +4,8 @@
  * Runs each subagent on the main thread and forwards AgentEvents for progress tracking.
  */
 import path from "node:path";
-import type { AgentEvent } from "@oh-my-pi/pi-agent-core";
-import type { Api, Model, ThinkingLevel, ToolChoice } from "@oh-my-pi/pi-ai";
+import type { AgentEvent, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { Api, Model, ToolChoice } from "@oh-my-pi/pi-ai";
 import { logger, untilAborted } from "@oh-my-pi/pi-utils";
 import type { TSchema } from "@sinclair/typebox";
 import Ajv, { type ValidateFunction } from "ajv";

package/src/task/types.ts

@@ -1,4 +1,5 @@
-import type { ThinkingLevel, Usage } from "@oh-my-pi/pi-ai";
+import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { Usage } from "@oh-my-pi/pi-ai";
 import { $env } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import type { NestedRepoPatch } from "./worktree";

package/src/thinking.ts

@@ -0,0 +1,87 @@
+import { type ResolvedThinkingLevel, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import { clampThinkingLevelForModel, type Effort, type Model, THINKING_EFFORTS } from "@oh-my-pi/pi-ai";
+
+/**
+ * Metadata used to render thinking selector values in the coding-agent UI.
+ */
+export interface ThinkingLevelMetadata {
+	value: ThinkingLevel;
+	label: string;
+	description: string;
+}
+
+const THINKING_LEVEL_METADATA: Record<ThinkingLevel, ThinkingLevelMetadata> = {
+	[ThinkingLevel.Inherit]: {
+		value: ThinkingLevel.Inherit,
+		label: "inherit",
+		description: "Inherit session default",
+	},
+	[ThinkingLevel.Off]: { value: ThinkingLevel.Off, label: "off", description: "No reasoning" },
+	[ThinkingLevel.Minimal]: {
+		value: ThinkingLevel.Minimal,
+		label: "min",
+		description: "Very brief reasoning (~1k tokens)",
+	},
+	[ThinkingLevel.Low]: { value: ThinkingLevel.Low, label: "low", description: "Light reasoning (~2k tokens)" },
+	[ThinkingLevel.Medium]: {
+		value: ThinkingLevel.Medium,
+		label: "medium",
+		description: "Moderate reasoning (~8k tokens)",
+	},
+	[ThinkingLevel.High]: { value: ThinkingLevel.High, label: "high", description: "Deep reasoning (~16k tokens)" },
+	[ThinkingLevel.XHigh]: {
+		value: ThinkingLevel.XHigh,
+		label: "xhigh",
+		description: "Maximum reasoning (~32k tokens)",
+	},
+};
+
+const THINKING_LEVELS = new Set<string>([ThinkingLevel.Inherit, ThinkingLevel.Off, ...THINKING_EFFORTS]);
+const EFFORT_LEVELS = new Set<string>(THINKING_EFFORTS);
+
+/**
+ * Parses a provider-facing effort value.
+ */
+export function parseEffort(value: string | null | undefined): Effort | undefined {
+	return value !== undefined && value !== null && EFFORT_LEVELS.has(value) ? (value as Effort) : undefined;
+}
+
+/**
+ * Parses an agent-local thinking selector.
+ */
+export function parseThinkingLevel(value: string | null | undefined): ThinkingLevel | undefined {
+	return value !== undefined && value !== null && THINKING_LEVELS.has(value) ? (value as ThinkingLevel) : undefined;
+}
+
+/**
+ * Returns display metadata for a thinking selector.
+ */
+export function getThinkingLevelMetadata(level: ThinkingLevel): ThinkingLevelMetadata {
+	return THINKING_LEVEL_METADATA[level];
+}
+
+/**
+ * Converts an agent-local selector into the effort sent to providers.
+ */
+export function toReasoningEffort(level: ThinkingLevel | undefined): Effort | undefined {
+	if (level === undefined || level === ThinkingLevel.Off || level === ThinkingLevel.Inherit) {
+		return undefined;
+	}
+	return level;
+}
+
+/**
+ * Resolves a selector against the current model while preserving explicit "off".
+ */
+export function resolveThinkingLevelForModel(
+	model: Model | undefined,
+	level: ThinkingLevel | undefined,
+): ResolvedThinkingLevel | undefined {
+	if (level === undefined || level === ThinkingLevel.Inherit) {
+		return undefined;
+	}
+	if (level === ThinkingLevel.Off) {
+		return ThinkingLevel.Off;
+	}
+	return clampThinkingLevelForModel(model, level);
+}

package/src/tools/browser.ts

@@ -517,15 +517,24 @@ export class BrowserTool implements AgentTool<typeof browserSchema, BrowserToolD
 				}
 			: DEFAULT_VIEWPORT;
 		const puppeteer = await loadPuppeteer();
+		const launchArgs = [
+			"--no-sandbox",
+			"--disable-setuid-sandbox",
+			"--disable-blink-features=AutomationControlled",
+			`--window-size=${initialViewport.width},${initialViewport.height}`,
+		];
+		const proxy = process.env.PUPPETEER_PROXY;
+		if (proxy) {
+			launchArgs.push(`--proxy-server=${proxy}`);
+		}
+		const ignoreCert = process.env.PUPPETEER_PROXY_IGNORE_CERT_ERRORS?.toLowerCase();
+		if (ignoreCert === "true" || ignoreCert === "1" || ignoreCert === "yes" || ignoreCert === "on") {
+			launchArgs.push("--ignore-certificate-errors");
+		}
 		this.#browser = await puppeteer.launch({
 			headless: this.#currentHeadless,
 			defaultViewport: this.#currentHeadless ? initialViewport : null,
-			args: [
-				"--no-sandbox",
-				"--disable-setuid-sandbox",
-				"--disable-blink-features=AutomationControlled",
-				`--window-size=${initialViewport.width},${initialViewport.height}`,
-			],
+			args: launchArgs,
 			ignoreDefaultArgs: [...STEALTH_IGNORE_DEFAULT_ARGS],
 		});
 		this.#page = await this.#browser.newPage();