@oh-my-pi/pi-coding-agent 15.5.9 → 15.5.11

package/src/modes/ultrathink.ts

@@ -0,0 +1,79 @@
+import ultrathinkNotice from "../prompts/system/ultrathink-notice.md" with { type: "text" };
+import { theme } from "./theme/theme";
+
+/**
+ * "ultrathink" keyword support, mirroring Claude Code's affordance.
+ *
+ * Typing the standalone word in the input editor paints it with a rainbow
+ * gradient ({@link highlightUltrathink}); submitting a message that mentions it
+ * appends a hidden {@link ULTRATHINK_NOTICE} nudging the model toward careful
+ * multi-step reasoning. Matching is word-bounded and case-insensitive, so
+ * "ultrathinking"/"ultrathinks" never trigger either behavior.
+ */
+
+// Cheap, stateless presence probe used to skip the boundary regex on most lines.
+const ULTRATHINK_PROBE = /ultrathink/i;
+// Detection: standalone keyword, any case. Non-global so `.test` stays stateless.
+const ULTRATHINK_WORD = /\bultrathink\b/i;
+// Highlight: global so `.replace` walks every occurrence.
+const ULTRATHINK_HIGHLIGHT = /\bultrathink\b/gi;
+
+/** Hidden system notice appended after a user message that mentions "ultrathink". */
+export const ULTRATHINK_NOTICE: string = ultrathinkNotice.trim();
+
+/** Whether `text` contains the standalone keyword "ultrathink" (any case). */
+export function containsUltrathink(text: string): boolean {
+	return ULTRATHINK_WORD.test(text);
+}
+
+const FG_RESET = "\x1b[39m";
+// Hue stops swept across the visible spectrum. More stops than the keyword has
+// letters so the gradient resolves smoothly regardless of casing/match length.
+const RAINBOW_STOPS = 14;
+
+let cachedMode: string | undefined;
+let cachedPalette: readonly string[] | undefined;
+
+/** Rainbow foreground escapes for the active color mode, compiled once per mode. */
+function rainbowPalette(): readonly string[] {
+	const mode = theme.getColorMode();
+	if (cachedPalette && cachedMode === mode) return cachedPalette;
+	const format = mode === "truecolor" ? "ansi-16m" : "ansi-256";
+	const palette: string[] = [];
+	for (let i = 0; i < RAINBOW_STOPS; i++) {
+		// Sweep red→violet (0..330°), stopping short of the wrap back to red.
+		const hue = Math.round((i / RAINBOW_STOPS) * 330);
+		palette.push(Bun.color(`hsl(${hue}, 90%, 62%)`, format) ?? "");
+	}
+	cachedMode = mode;
+	cachedPalette = palette;
+	return palette;
+}
+
+/** Paint each character of `word` with the next rainbow stop, resetting fg after. */
+function rainbow(word: string): string {
+	const palette = rainbowPalette();
+	const n = word.length;
+	let out = "";
+	let prev = "";
+	for (let i = 0; i < n; i++) {
+		const color = palette[Math.floor((i / n) * palette.length)] ?? palette[0] ?? "";
+		// Coalesce consecutive characters that resolve to the same stop.
+		if (color !== prev) {
+			out += color;
+			prev = color;
+		}
+		out += word[i];
+	}
+	return `${out}${FG_RESET}`;
+}
+
+/**
+ * Rainbow-highlight every standalone "ultrathink" in `text` for editor display.
+ * Adds only zero-width SGR escapes — the visible width is unchanged — and returns
+ * the input untouched when the keyword is absent.
+ */
+export function highlightUltrathink(text: string): string {
+	if (!ULTRATHINK_PROBE.test(text)) return text;
+	return text.replace(ULTRATHINK_HIGHLIGHT, rainbow);
+}

package/src/prompts/system/ultrathink-notice.md

@@ -0,0 +1,3 @@
+<system-notice>
+This task involves multi-step reasoning. Think carefully through the problem before responding.
+</system-notice>

package/src/session/agent-session.ts

@@ -148,6 +148,7 @@ import type { HindsightSessionState } from "../hindsight/state";
 import { type LocalProtocolOptions, resolveLocalUrlToPath } from "../internal-urls";
 import { resolveMemoryBackend } from "../memory-backend";
 import { getCurrentThemeName, theme } from "../modes/theme/theme";
+import { containsUltrathink, ULTRATHINK_NOTICE } from "../modes/ultrathink";
 import type { PlanModeState } from "../plan-mode/state";
 import autoContinuePrompt from "../prompts/system/auto-continue.md" with { type: "text" };
 import eagerTodoPrompt from "../prompts/system/eager-todo.md" with { type: "text" };
@@ -196,6 +197,7 @@ import {
 	type PythonExecutionMessage,
 	readPendingDisplayTag,
 	SILENT_ABORT_MARKER,
+	stripImagesFromMessage,
 } from "./messages";
 import { formatSessionDumpText } from "./session-dump-format";
 import type {
@@ -3996,6 +3998,21 @@ export class AgentSession {
 		// Expand file-based prompt templates if requested
 		const expandedText = expandPromptTemplates ? expandPromptTemplate(text, [...this.#promptTemplates]) : text;
 
+		// "ultrathink" keyword: nudge the model toward careful multi-step reasoning by
+		// appending a hidden notice after the user's message. User-authored prompts only —
+		// synthetic/agent-initiated turns never trigger it.
+		const ultrathinkNotice: CustomMessage | undefined =
+			!options?.synthetic && containsUltrathink(expandedText)
+				? {
+						role: "custom",
+						customType: "ultrathink-notice",
+						content: ULTRATHINK_NOTICE,
+						display: false,
+						attribution: "user",
+						timestamp: Date.now(),
+					}
+				: undefined;
+
 		// If streaming, queue via steer() or followUp() based on option
 		if (this.isStreaming) {
 			if (!options?.streamingBehavior) {
@@ -4006,6 +4023,10 @@ export class AgentSession {
 			} else {
 				await this.#queueSteer(expandedText, options?.images);
 			}
+			// Steer/follow-up the ultrathink notice alongside the queued user message.
+			if (ultrathinkNotice) {
+				await this.sendCustomMessage(ultrathinkNotice, { deliverAs: options.streamingBehavior });
+			}
 			return;
 		}
 
@@ -4034,6 +4055,7 @@ export class AgentSession {
 			await this.#promptWithMessage(message, expandedText, {
 				...options,
 				prependMessages: eagerTodoPrelude ? [eagerTodoPrelude.message] : undefined,
+				appendMessages: ultrathinkNotice ? [ultrathinkNotice] : undefined,
 			});
 		} finally {
 			// Clean up residual eager-todo directive if the prompt never consumed it
@@ -4083,6 +4105,7 @@ export class AgentSession {
 		expandedText: string,
 		options?: Pick<PromptOptions, "toolChoice" | "images" | "skipCompactionCheck"> & {
 			prependMessages?: AgentMessage[];
+			appendMessages?: AgentMessage[];
 			skipPostPromptRecoveryWait?: boolean;
 		},
 	): Promise<void> {
@@ -4146,6 +4169,12 @@ export class AgentSession {
 
 			messages.push(message);
 
+			// Inject the ultrathink notice (and any other per-turn appends) right after the
+			// user message so the model reads it as part of the same turn.
+			if (options?.appendMessages) {
+				messages.push(...options.appendMessages);
+			}
+
 			// Early bail-out: if a newer abort/prompt cycle started during setup,
 			// return before mutating shared state (nextTurn messages, system prompt).
 			if (this.#promptGeneration !== generation) {
@@ -5310,6 +5339,55 @@ export class AgentSession {
 		return result;
 	}
 
+	/**
+	 * Strip image content blocks from every message on the current branch and
+	 * persist the rewrite. Walks `SessionManager.getBranch()` in place — both
+	 * `SessionMessageEntry.message` and `CustomMessageEntry.content` arrays
+	 * are mutated, then `rewriteEntries` durably commits the new shape. The
+	 * agent's runtime view is rebuilt from the freshly-mutated entries so any
+	 * provider sessions caching message identity (Codex Responses) are torn
+	 * down to force a clean replay on the next turn.
+	 *
+	 * No-op when the branch carries no images; returns `{ removed: 0 }` and
+	 * skips the disk rewrite.
+	 */
+	async dropImages(): Promise<{ removed: number }> {
+		const branchEntries = this.sessionManager.getBranch();
+		let removed = 0;
+		for (const entry of branchEntries) {
+			if (entry.type === "message") {
+				removed += stripImagesFromMessage(entry.message);
+				continue;
+			}
+			if (entry.type === "custom_message" && typeof entry.content !== "string") {
+				const kept: typeof entry.content = [];
+				let dropped = 0;
+				for (const part of entry.content) {
+					if (part.type === "image") {
+						dropped++;
+					} else {
+						kept.push(part);
+					}
+				}
+				if (dropped > 0) {
+					if (kept.length === 0) {
+						kept.push({ type: "text", text: "[image removed]" });
+					}
+					entry.content = kept;
+					removed += dropped;
+				}
+			}
+		}
+		if (removed === 0) {
+			return { removed: 0 };
+		}
+		await this.sessionManager.rewriteEntries();
+		const sessionContext = this.buildDisplaySessionContext();
+		this.agent.replaceMessages(sessionContext.messages);
+		this.#closeCodexProviderSessionsForHistoryRewrite();
+		return { removed };
+	}
+
 	/**
 	 * Manually compact the session context.
 	 * Aborts current agent operation first.
@@ -6379,6 +6457,14 @@ export class AgentSession {
 	}
 	#isCompactionAuthFailure(error: unknown): boolean {
 		if (!(error instanceof Error)) return false;
+		// Real provider 401/403 — surfaced as `.status` by the compaction layer
+		// (see `createSummarizationError` in packages/agent/src/compaction/compaction.ts).
+		// Without this branch, an expired/revoked Anthropic key would bypass the
+		// authenticated-fallback path and dump the raw HTTP body into the UI.
+		const status = (error as Error & { status?: number }).status;
+		if (status === 401 || status === 403) return true;
+		// pi-native gateway synthetic for "no credential configured" (issue #986).
+		// Carries no HTTP status, so the legacy message regex stays.
 		return /auth_unavailable|no auth available/i.test(error.message);
 	}
 

package/src/session/messages.ts

@@ -114,6 +114,98 @@ function getPrunedToolResultContent(message: ToolResultMessage): (TextContent |
 	return [{ type: "text", text }];
 }
 
+/** Result of filtering image blocks out of a `(TextContent | ImageContent)[]` array. */
+interface StripContentResult {
+	content: (TextContent | ImageContent)[];
+	removed: number;
+}
+
+function stripImagesFromArrayContent(content: (TextContent | ImageContent)[]): StripContentResult {
+	let removed = 0;
+	const kept: (TextContent | ImageContent)[] = [];
+	for (const part of content) {
+		if (part.type === "image") {
+			removed++;
+		} else {
+			kept.push(part);
+		}
+	}
+	if (removed === 0) {
+		return { content, removed };
+	}
+	// Avoid emitting an empty `content` array — providers reject zero-block user/tool
+	// messages and the LLM still needs to see *something* where the image used to be.
+	if (kept.length === 0) {
+		kept.push({ type: "text", text: "[image removed]" });
+	}
+	return { content: kept, removed };
+}
+
+/**
+ * Strip image content blocks from `message` in place. Returns the count of
+ * images removed across `content` (every role that carries `ImageContent`) and
+ * any tool-result `details.images` payload. Callers MUST rewrite session
+ * entries (`SessionManager.rewriteEntries`) and replay them through
+ * `Agent.replaceMessages` afterwards so persisted state and provider-side
+ * caches stay aligned with the mutated tree — `stripImagesFromMessage` is a
+ * pure local mutation and intentionally does neither.
+ */
+export function stripImagesFromMessage(message: AgentMessage): number {
+	switch (message.role) {
+		case "user":
+		case "developer":
+		case "custom":
+		case "hookMessage": {
+			if (typeof message.content === "string") return 0;
+			const { content, removed } = stripImagesFromArrayContent(message.content);
+			if (removed > 0) {
+				// All four roles type `content` as `string | (TextContent | ImageContent)[]`;
+				// TypeScript can't narrow the assignment across the union, so cast once.
+				(message as { content: typeof content }).content = content;
+			}
+			return removed;
+		}
+		case "toolResult": {
+			let removed = 0;
+			const { content, removed: contentRemoved } = stripImagesFromArrayContent(message.content);
+			if (contentRemoved > 0) {
+				message.content = content;
+				removed += contentRemoved;
+			}
+			const details = message.details as { images?: unknown } | null | undefined;
+			if (details && Array.isArray(details.images)) {
+				const original = details.images as unknown[];
+				const kept: unknown[] = [];
+				for (const candidate of original) {
+					const looksLikeImageBlock =
+						!!candidate && typeof candidate === "object" && (candidate as { type?: unknown }).type === "image";
+					if (looksLikeImageBlock) {
+						removed++;
+					} else {
+						kept.push(candidate);
+					}
+				}
+				if (kept.length !== original.length) {
+					details.images = kept;
+				}
+			}
+			return removed;
+		}
+		case "fileMention": {
+			let removed = 0;
+			for (const file of message.files) {
+				if (file.image) {
+					file.image = undefined;
+					removed++;
+				}
+			}
+			return removed;
+		}
+		default:
+			return 0;
+	}
+}
+
 /**
  * Message type for bash executions via the ! command.
  */