@oh-my-pi/pi-coding-agent 14.9.1 → 14.9.3

package/src/extensibility/extensions/runner.ts

@@ -60,6 +60,15 @@ interface BeforeAgentStartCombinedResult {
 
 export type ExtensionErrorListener = (error: ExtensionError) => void;
 
+export const EXTENSION_HANDLER_TIMEOUT_MS = 30_000;
+let extensionHandlerTimeoutMs = EXTENSION_HANDLER_TIMEOUT_MS;
+
+export function __test_setExtensionHandlerTimeoutMs(timeoutMs: number): void {
+	extensionHandlerTimeoutMs = timeoutMs;
+}
+
+const EXTENSION_HANDLER_TIMEOUT = Symbol("extensionHandlerTimeout");
+
 /**
  * Events handled by the generic emit() method.
  * Events with dedicated emitXxx() methods are excluded for stronger type safety.
@@ -434,6 +443,46 @@ export class ExtensionRunner {
 		);
 	}
 
+	async #runHandlerWithTimeout<TEvent extends { type: string }, TResult>(
+		handler: (event: TEvent, ctx: ExtensionContext) => Promise<TResult | undefined> | TResult | undefined,
+		event: TEvent,
+		ctx: ExtensionContext,
+		ext: Extension,
+		timeoutMs: number,
+	): Promise<TResult | undefined> {
+		try {
+			const handlerResult = await Promise.race([
+				Promise.resolve(handler(event, ctx)),
+				Bun.sleep(timeoutMs).then(() => EXTENSION_HANDLER_TIMEOUT),
+			]);
+			if (handlerResult === EXTENSION_HANDLER_TIMEOUT) {
+				const error = `handler timed out after ${timeoutMs}ms`;
+				logger.warn("Extension handler timed out", {
+					extensionPath: ext.path,
+					event: event.type,
+					timeoutMs,
+				});
+				this.emitError({
+					extensionPath: ext.path,
+					event: event.type,
+					error,
+				});
+				return undefined;
+			}
+			return handlerResult as TResult | undefined;
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			const stack = err instanceof Error ? err.stack : undefined;
+			this.emitError({
+				extensionPath: ext.path,
+				event: event.type,
+				error: message,
+				stack,
+			});
+			return undefined;
+		}
+	}
+
 	async emit<TEvent extends RunnerEmitEvent>(event: TEvent): Promise<RunnerEmitResult<TEvent>> {
 		const ctx = this.createContext();
 		let result: SessionBeforeEventResult | SessionCompactingResult | undefined;
@@ -443,28 +492,23 @@ export class ExtensionRunner {
 			if (!handlers || handlers.length === 0) continue;
 
 			for (const handler of handlers) {
-				try {
-					const handlerResult = await handler(event, ctx);
-
-					if (this.#isSessionBeforeEvent(event) && handlerResult) {
-						result = handlerResult as SessionBeforeEventResult;
-						if (result.cancel) {
-							return result as RunnerEmitResult<TEvent>;
-						}
+				const handlerResult = await this.#runHandlerWithTimeout(
+					handler,
+					event,
+					ctx,
+					ext,
+					extensionHandlerTimeoutMs,
+				);
+
+				if (this.#isSessionBeforeEvent(event) && handlerResult) {
+					result = handlerResult as SessionBeforeEventResult;
+					if (result.cancel) {
+						return result as RunnerEmitResult<TEvent>;
 					}
+				}
 
-					if (event.type === "session.compacting" && handlerResult) {
-						result = handlerResult as SessionCompactingResult;
-					}
-				} catch (err) {
-					const message = err instanceof Error ? err.message : String(err);
-					const stack = err instanceof Error ? err.stack : undefined;
-					this.emitError({
-						extensionPath: ext.path,
-						event: event.type,
-						error: message,
-						stack,
-					});
+				if (event.type === "session.compacting" && handlerResult) {
+					result = handlerResult as SessionCompactingResult;
 				}
 			}
 		}
@@ -482,31 +526,26 @@ export class ExtensionRunner {
 			if (!handlers || handlers.length === 0) continue;
 
 			for (const handler of handlers) {
-				try {
-					const handlerResult = (await handler(currentEvent, ctx)) as ToolResultEventResult | undefined;
-					if (!handlerResult) continue;
-
-					if (handlerResult.content !== undefined) {
-						currentEvent.content = handlerResult.content;
-						modified = true;
-					}
-					if (handlerResult.details !== undefined) {
-						currentEvent.details = handlerResult.details;
-						modified = true;
-					}
-					if (handlerResult.isError !== undefined) {
-						currentEvent.isError = handlerResult.isError;
-						modified = true;
-					}
-				} catch (err) {
-					const message = err instanceof Error ? err.message : String(err);
-					const stack = err instanceof Error ? err.stack : undefined;
-					this.emitError({
-						extensionPath: ext.path,
-						event: "tool_result",
-						error: message,
-						stack,
-					});
+				const handlerResult = (await this.#runHandlerWithTimeout(
+					handler,
+					currentEvent,
+					ctx,
+					ext,
+					extensionHandlerTimeoutMs,
+				)) as ToolResultEventResult | undefined;
+				if (!handlerResult) continue;
+
+				if (handlerResult.content !== undefined) {
+					currentEvent.content = handlerResult.content;
+					modified = true;
+				}
+				if (handlerResult.details !== undefined) {
+					currentEvent.details = handlerResult.details;
+					modified = true;
+				}
+				if (handlerResult.isError !== undefined) {
+					currentEvent.isError = handlerResult.isError;
+					modified = true;
 				}
 			}
 		}
@@ -574,20 +613,15 @@ export class ExtensionRunner {
 			if (!handlers || handlers.length === 0) continue;
 
 			for (const handler of handlers) {
-				try {
-					const handlerResult = await handler(event, ctx);
-					if (handlerResult) {
-						return handlerResult as R;
-					}
-				} catch (err) {
-					const message = err instanceof Error ? err.message : String(err);
-					const stack = err instanceof Error ? err.stack : undefined;
-					this.emitError({
-						extensionPath: ext.path,
-						event: eventName,
-						error: message,
-						stack,
-					});
+				const handlerResult = await this.#runHandlerWithTimeout(
+					handler,
+					event,
+					ctx,
+					ext,
+					extensionHandlerTimeoutMs,
+				);
+				if (handlerResult) {
+					return handlerResult as R;
 				}
 			}
 		}
@@ -613,29 +647,24 @@ export class ExtensionRunner {
 			if (!handlers || handlers.length === 0) continue;
 
 			for (const handler of handlers) {
-				try {
-					const event: ResourcesDiscoverEvent = { type: "resources_discover", cwd, reason };
-					const handlerResult = await handler(event, ctx);
-					const result = handlerResult as ResourcesDiscoverResult | undefined;
-
-					if (result?.skillPaths?.length) {
-						skillPaths.push(...result.skillPaths.map(path => ({ path, extensionPath: ext.path })));
-					}
-					if (result?.promptPaths?.length) {
-						promptPaths.push(...result.promptPaths.map(path => ({ path, extensionPath: ext.path })));
-					}
-					if (result?.themePaths?.length) {
-						themePaths.push(...result.themePaths.map(path => ({ path, extensionPath: ext.path })));
-					}
-				} catch (err) {
-					const message = err instanceof Error ? err.message : String(err);
-					const stack = err instanceof Error ? err.stack : undefined;
-					this.emitError({
-						extensionPath: ext.path,
-						event: "resources_discover",
-						error: message,
-						stack,
-					});
+				const event: ResourcesDiscoverEvent = { type: "resources_discover", cwd, reason };
+				const handlerResult = await this.#runHandlerWithTimeout(
+					handler,
+					event,
+					ctx,
+					ext,
+					extensionHandlerTimeoutMs,
+				);
+				const result = handlerResult as ResourcesDiscoverResult | undefined;
+
+				if (result?.skillPaths?.length) {
+					skillPaths.push(...result.skillPaths.map(path => ({ path, extensionPath: ext.path })));
+				}
+				if (result?.promptPaths?.length) {
+					promptPaths.push(...result.promptPaths.map(path => ({ path, extensionPath: ext.path })));
+				}
+				if (result?.themePaths?.length) {
+					themePaths.push(...result.themePaths.map(path => ({ path, extensionPath: ext.path })));
 				}
 			}
 		}
@@ -655,21 +684,14 @@ export class ExtensionRunner {
 
 		for (const ext of this.extensions) {
 			for (const handler of ext.handlers.get("input") ?? []) {
-				try {
-					const event: InputEvent = { type: "input", text: currentText, images: currentImages, source };
-					const result = (await handler(event, ctx)) as InputEventResult | undefined;
-					if (result?.handled) return result;
-					if (result?.text !== undefined) {
-						currentText = result.text;
-						currentImages = result.images ?? currentImages;
-					}
-				} catch (err) {
-					this.emitError({
-						extensionPath: ext.path,
-						event: "input",
-						error: err instanceof Error ? err.message : String(err),
-						stack: err instanceof Error ? err.stack : undefined,
-					});
+				const event: InputEvent = { type: "input", text: currentText, images: currentImages, source };
+				const result = (await this.#runHandlerWithTimeout(handler, event, ctx, ext, extensionHandlerTimeoutMs)) as
+					| InputEventResult
+					| undefined;
+				if (result?.handled) return result;
+				if (result?.text !== undefined) {
+					currentText = result.text;
+					currentImages = result.images ?? currentImages;
 				}
 			}
 		}
@@ -704,22 +726,17 @@ export class ExtensionRunner {
 			if (!handlers || handlers.length === 0) continue;
 
 			for (const handler of handlers) {
-				try {
-					const event: ContextEvent = { type: "context", messages: currentMessages };
-					const handlerResult = await handler(event, ctx);
-
-					if (handlerResult && (handlerResult as ContextEventResult).messages) {
-						currentMessages = (handlerResult as ContextEventResult).messages!;
-					}
-				} catch (err) {
-					const message = err instanceof Error ? err.message : String(err);
-					const stack = err instanceof Error ? err.stack : undefined;
-					this.emitError({
-						extensionPath: ext.path,
-						event: "context",
-						error: message,
-						stack,
-					});
+				const event: ContextEvent = { type: "context", messages: currentMessages };
+				const handlerResult = await this.#runHandlerWithTimeout(
+					handler,
+					event,
+					ctx,
+					ext,
+					extensionHandlerTimeoutMs,
+				);
+
+				if (handlerResult && (handlerResult as ContextEventResult).messages) {
+					currentMessages = (handlerResult as ContextEventResult).messages!;
 				}
 			}
 		}
@@ -736,24 +753,19 @@ export class ExtensionRunner {
 			if (!handlers || handlers.length === 0) continue;
 
 			for (const handler of handlers) {
-				try {
-					const event: BeforeProviderRequestEvent = {
-						type: "before_provider_request",
-						payload: currentPayload,
-					};
-					const handlerResult = await handler(event, ctx);
-					if (handlerResult !== undefined) {
-						currentPayload = handlerResult;
-					}
-				} catch (err) {
-					const message = err instanceof Error ? err.message : String(err);
-					const stack = err instanceof Error ? err.stack : undefined;
-					this.emitError({
-						extensionPath: ext.path,
-						event: "before_provider_request",
-						error: message,
-						stack,
-					});
+				const event: BeforeProviderRequestEvent = {
+					type: "before_provider_request",
+					payload: currentPayload,
+				};
+				const handlerResult = await this.#runHandlerWithTimeout(
+					handler,
+					event,
+					ctx,
+					ext,
+					extensionHandlerTimeoutMs,
+				);
+				if (handlerResult !== undefined) {
+					currentPayload = handlerResult;
 				}
 			}
 		}
@@ -769,25 +781,14 @@ export class ExtensionRunner {
 			if (!handlers || handlers.length === 0) continue;
 
 			for (const handler of handlers) {
-				try {
-					const event: AfterProviderResponseEvent = {
-						type: "after_provider_response",
-						status: response.status,
-						headers: response.headers,
-						requestId: response.requestId,
-						metadata: response.metadata,
-					};
-					await handler(event, ctx);
-				} catch (err) {
-					const message = err instanceof Error ? err.message : String(err);
-					const stack = err instanceof Error ? err.stack : undefined;
-					this.emitError({
-						extensionPath: ext.path,
-						event: "after_provider_response",
-						error: message,
-						stack,
-					});
-				}
+				const event: AfterProviderResponseEvent = {
+					type: "after_provider_response",
+					status: response.status,
+					headers: response.headers,
+					requestId: response.requestId,
+					metadata: response.metadata,
+				};
+				await this.#runHandlerWithTimeout(handler, event, ctx, ext, extensionHandlerTimeoutMs);
 			}
 		}
 	}
@@ -807,34 +808,29 @@ export class ExtensionRunner {
 			if (!handlers || handlers.length === 0) continue;
 
 			for (const handler of handlers) {
-				try {
-					const event: BeforeAgentStartEvent = {
-						type: "before_agent_start",
-						prompt,
-						images,
-						systemPrompt: currentSystemPrompt,
-					};
-					const handlerResult = await handler(event, ctx);
-
-					if (handlerResult) {
-						const result = handlerResult as BeforeAgentStartEventResult;
-						if (result.message) {
-							messages.push(result.message);
-						}
-						if (result.systemPrompt !== undefined) {
-							currentSystemPrompt = result.systemPrompt;
-							systemPromptModified = true;
-						}
+				const event: BeforeAgentStartEvent = {
+					type: "before_agent_start",
+					prompt,
+					images,
+					systemPrompt: currentSystemPrompt,
+				};
+				const handlerResult = await this.#runHandlerWithTimeout(
+					handler,
+					event,
+					ctx,
+					ext,
+					extensionHandlerTimeoutMs,
+				);
+
+				if (handlerResult) {
+					const result = handlerResult as BeforeAgentStartEventResult;
+					if (result.message) {
+						messages.push(result.message);
+					}
+					if (result.systemPrompt !== undefined) {
+						currentSystemPrompt = result.systemPrompt;
+						systemPromptModified = true;
 					}
-				} catch (err) {
-					const message = err instanceof Error ? err.message : String(err);
-					const stack = err instanceof Error ? err.stack : undefined;
-					this.emitError({
-						extensionPath: ext.path,
-						event: "before_agent_start",
-						error: message,
-						stack,
-					});
 				}
 			}
 		}

package/src/hashline/apply.ts

@@ -1,6 +1,6 @@
 import { HashlineMismatchError } from "./anchors";
 import { RANGE_INTERIOR_HASH } from "./constants";
-import { computeLineHash, HL_EDIT_SEP } from "./hash";
+import { computeLineHash } from "./hash";
 import { cloneCursor } from "./parser";
 import type { Anchor, HashlineApplyOptions, HashlineCursor, HashlineEdit, HashMismatch } from "./types";
 
@@ -37,7 +37,6 @@ interface HashlineReplacementGroup {
 
 function getHashlineEditAnchors(edit: HashlineEdit): Anchor[] {
 	if (edit.kind === "delete") return [edit.anchor];
-	if (edit.kind === "modify") return [edit.anchor];
 	if (edit.cursor.kind === "before_anchor") return [edit.cursor.anchor];
 	if (edit.cursor.kind === "after_anchor") return [edit.cursor.anchor];
 	return [];
@@ -96,7 +95,7 @@ function insertAtEnd(fileLines: string[], lineOrigins: HashlineLineOrigin[], lin
 /** Bucket edits by the line they target so we can apply each line's group in one splice. */
 
 function getAnchorTargetLine(edit: HashlineEdit): number | undefined {
-	if (edit.kind === "delete" || edit.kind === "modify") return edit.anchor.line;
+	if (edit.kind === "delete") return edit.anchor.line;
 	if (edit.cursor.kind === "before_anchor" || edit.cursor.kind === "after_anchor") return edit.cursor.anchor.line;
 	return undefined;
 }
@@ -607,11 +606,9 @@ function bucketAnchorEditsByLine(edits: IndexedEdit[]): Map<number, IndexedEdit[
 		const line =
 			entry.edit.kind === "delete"
 				? entry.edit.anchor.line
-				: entry.edit.kind === "modify"
-					? entry.edit.anchor.line
-					: entry.edit.cursor.kind === "before_anchor"
-						? entry.edit.cursor.anchor.line
-						: 0;
+				: entry.edit.cursor.kind === "before_anchor"
+					? entry.edit.cursor.anchor.line
+					: 0;
 		const bucket = byLine.get(line);
 		if (bucket) bucket.push(entry);
 		else byLine.set(line, [entry]);
@@ -683,33 +680,20 @@ export function applyHashlineEdits(
 		const currentLine = fileLines[idx] ?? "";
 		const beforeLines: string[] = [];
 		let deleteLine = false;
-		let prefix = "";
-		let suffix = "";
-		let modified = false;
 
 		for (const { edit } of bucket) {
 			if (edit.kind === "insert") {
 				beforeLines.push(edit.text);
 			} else if (edit.kind === "delete") {
 				deleteLine = true;
-			} else if (edit.kind === "modify") {
-				prefix = edit.prefix + prefix;
-				suffix = suffix + edit.suffix;
-				modified = true;
 			}
 		}
-		if (beforeLines.length === 0 && !deleteLine && !modified) continue;
-		if (deleteLine && modified) {
-			throw new Error(
-				`line ${line}: cannot combine inline modify ("< ${line}${HL_EDIT_SEP}…" or "+ ${line}${HL_EDIT_SEP}…") with a delete or replace targeting the same line.`,
-			);
-		}
+		if (beforeLines.length === 0 && !deleteLine) continue;
 
-		const effectiveLine = modified ? prefix + currentLine + suffix : currentLine;
-		const replacement = deleteLine ? beforeLines : [...beforeLines, effectiveLine];
+		const replacement = deleteLine ? beforeLines : [...beforeLines, currentLine];
 		const origins = replacement.map((): HashlineLineOrigin => (deleteLine ? "replacement" : "insert"));
 		if (!deleteLine) {
-			origins[origins.length - 1] = modified ? "replacement" : (lineOrigins[idx] ?? "original");
+			origins[origins.length - 1] = lineOrigins[idx] ?? "original";
 		}
 
 		fileLines.splice(idx, 1, ...replacement);

package/src/hashline/constants.ts

@@ -6,3 +6,23 @@ export const RANGE_INTERIOR_HASH = "**";
 
 /** Header marker introducing a new file section in multi-section input. */
 export const FILE_HEADER_PREFIX = "@";
+
+/** Optional patch envelope start marker; silently consumed when present. */
+export const BEGIN_PATCH_MARKER = "*** Begin Patch";
+
+/** Optional patch envelope end marker; terminates parsing when encountered. */
+export const END_PATCH_MARKER = "*** End Patch";
+
+/**
+ * Recovery sentinel emitted by the agent loop when a contaminated
+ * `to=functions.edit` stream is truncated mid-call (see
+ * `docs/ERRATA-GPT5-HARMONY.md`). Behaves like `END_PATCH_MARKER` for
+ * parsing — terminates the line loop — and additionally surfaces a
+ * warning in the tool result so the model knows to re-issue any
+ * remaining edits.
+ */
+export const ABORT_MARKER = "*** Abort";
+
+/** Warning text appended to the tool result when ABORT_MARKER terminates parsing. */
+export const ABORT_WARNING =
+	"Tool stream truncated mid-call due to detected output corruption. Applied ops above are valid. Re-issue any remaining edits.";

package/src/hashline/execute.ts

@@ -42,7 +42,6 @@ async function readHashlineFile(absolutePath: string, pathText: string): Promise
 function hasAnchorScopedEdit(edits: HashlineEdit[]): boolean {
 	return edits.some(edit => {
 		if (edit.kind === "delete") return true;
-		if (edit.kind === "modify") return true;
 		return edit.cursor.kind === "before_anchor" || edit.cursor.kind === "after_anchor";
 	});
 }

package/src/hashline/grammar.lark

@@ -1,33 +1,22 @@
-%import common.LF
-%import common.WS_INLINE
-
-start: section+
-
-section: file_header line_op*
-
-file_header: "@" path LF
+start: begin_patch hunk+ end_patch
+begin_patch: "*** Begin Patch" LF
+end_patch: "*** End Patch" LF?
 
-line_op: inline_before_op payload*
-       | inline_after_op payload*
-       | insert_before_op payload+
-       | insert_after_op payload+
-       | replace_op payload*
-       | delete_op
-       | blank
+hunk: update_hunk
+update_hunk: "@" filename LF line_op*
 
-inline_before_op: "<" LID $HSEP$ line_text? LF
-inline_after_op: "+" LID $HSEP$ line_text? LF
-insert_before_op: "<" insert_target LF
-insert_after_op: "+" insert_target LF
-replace_op: "=" range LF
-delete_op: "-" range LF
-payload: $HSEP$ line_text? LF
+filename: /(.+)/
 
-line_text: /[^\r\n]+/
+line_op: insert_before | insert_after | replace | delete | blank
+insert_before: ("<" | "< ") anchor LF payload+
+insert_after: ("+" | "+ ") anchor LF payload+
+replace: ("=" | "= ") range LF payload*
+delete: ("-" | "- ") range LF
+payload: $HSEP$ /(.*)/ LF
+blank: LF
 
-insert_target: LID | "EOF" | "BOF"
+anchor: LID | "EOF" | "BOF"
 range: LID ".." LID
+LID: /[1-9]\d*$HFMT$/
 
-path: /(?:[^\s\r\n]+|"[^"\r\n]+"|'[^'\r\n]+')/
-LID: /[1-9][0-9]*$HFMT$/
-blank: LF
+%import common.LF

package/src/hashline/hash.ts

@@ -137,48 +137,18 @@ export const HL_BODY_SEP = "|";
 export const HL_BODY_SEP_RE_RAW = regexEscape(HL_BODY_SEP);
 
 const RE_SIGNIFICANT = /[\p{L}\p{N}]/u;
-const RE_STRUCTURAL_STRIP = /[\s{}]/g;
-
-/**
- * Bigram returned for lines that contain only whitespace and `{`/`}`.
- * Picks the English ordinal suffix for the line number (`1` → `st`,
- * `2` → `nd`, `3` → `rd`, `11`/`12`/`13` → `th`, else `th`) so the
- * line digits + bigram BPE-merge into a single ordinal token (`1st`, `42nd`,
- * `100th`, …). Brace-only lines therefore cost one token for the whole
- * `LINE+ID` anchor instead of two.
- */
-function structuralBigram(line: number): string {
-	const mod100 = line % 100;
-	if (mod100 >= 11 && mod100 <= 13) return "th";
-	switch (line % 10) {
-		case 1:
-			return "st";
-		case 2:
-			return "nd";
-		case 3:
-			return "rd";
-		default:
-			return "th";
-	}
-}
 
 /**
  * Compute a 2-character hash of a single line via xxHash32 mod 647 over
- * {@link HL_BIGRAMS}. Lines that contain only whitespace and `{`/`}` collapse
- * to an ordinal-suffix bigram (see {@link structuralBigram}) so brace-only
- * structure shares one merged ordinal token (`1st`, `42nd`, `100th`, …).
- * Other lines with no letter or digit mix the line number into the seed so
- * adjacent identical punctuation-only lines get distinct hashes; lines with
- * significant content stay line-number-independent so a line is identifiable
- * across small shifts.
+ * {@link HL_BIGRAMS}. Lines with no letter or digit mix the line number
+ * into the seed so adjacent identical punctuation-only lines (e.g. brace-only
+ * lines) get distinct hashes; lines with significant content stay
+ * line-number-independent so a line is identifiable across small shifts.
  *
  * The line input should not include a trailing newline.
  */
 export function computeLineHash(idx: number, line: string): string {
 	line = line.replace(/\r/g, "").trimEnd();
-	if (line.replace(RE_STRUCTURAL_STRIP, "").length === 0) {
-		return structuralBigram(idx);
-	}
 	const seed = RE_SIGNIFICANT.test(line) ? 0 : idx;
 	return HL_BIGRAMS[Bun.hash.xxHash32(line, seed) % HL_BIGRAMS_COUNT];
 }