@oh-my-pi/pi-coding-agent 6.8.4 → 6.8.5

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## [Unreleased]
 
+## [6.8.5] - 2026-01-21
+### Breaking Changes
+
+- Changed timeout parameter from seconds to milliseconds in Python tool
+- Updated PythonExecutorOptions interface to use timeoutMs instead of timeout
+
+### Changed
+
+- Updated default timeout to 30000ms (30 seconds) for Python tool
+- Improved streaming output handling and buffer management
+
 ## [6.8.4] - 2026-01-21
 ### Changed
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "6.8.4",
+	"version": "6.8.5",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -40,11 +40,11 @@
 		"prepublishOnly": "bun run generate-template && bun run clean && bun run build"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-agent-core": "6.8.4",
-		"@oh-my-pi/pi-ai": "6.8.4",
-		"@oh-my-pi/pi-git-tool": "6.8.4",
-		"@oh-my-pi/pi-tui": "6.8.4",
-		"@oh-my-pi/pi-utils": "6.8.4",
+		"@oh-my-pi/pi-agent-core": "6.8.5",
+		"@oh-my-pi/pi-ai": "6.8.5",
+		"@oh-my-pi/pi-git-tool": "6.8.5",
+		"@oh-my-pi/pi-tui": "6.8.5",
+		"@oh-my-pi/pi-utils": "6.8.5",
 		"@openai/agents": "^0.3.7",
 		"@sinclair/typebox": "^0.34.46",
 		"ajv": "^8.17.1",

package/src/core/python-executor.ts

@@ -14,9 +14,9 @@ export interface PythonExecutorOptions {
 	/** Working directory for command execution */
 	cwd?: string;
 	/** Timeout in milliseconds */
-	timeout?: number;
+	timeoutMs?: number;
 	/** Callback for streaming output chunks (already sanitized) */
-	onChunk?: (chunk: string) => void;
+	onChunk?: (chunk: string) => Promise<void> | void;
 	/** AbortSignal for cancellation */
 	signal?: AbortSignal;
 	/** Session identifier for kernel reuse */
@@ -216,17 +216,13 @@ async function executeWithKernel(
 	try {
 		const result = await kernel.execute(code, {
 			signal: options?.signal,
-			timeoutMs: options?.timeout,
-			onChunk: (text) => {
-				sink.push(text);
-			},
-			onDisplay: (output) => {
-				displayOutputs.push(output);
-			},
+			timeoutMs: options?.timeoutMs,
+			onChunk: (text) => sink.push(text),
+			onDisplay: (output) => void displayOutputs.push(output),
 		});
 
 		if (result.cancelled) {
-			const secs = options?.timeout ? Math.round(options.timeout / 1000) : undefined;
+			const secs = options?.timeoutMs ? Math.round(options.timeoutMs / 1000) : undefined;
 			const annotation =
 				result.timedOut && secs !== undefined ? `Command timed out after ${secs} seconds` : undefined;
 			return {

package/src/core/streaming-output.ts

@@ -33,8 +33,6 @@ export class OutputSink {
 		path: string;
 		sink: Bun.FileSink;
 	};
-	#bytesWritten: number = 0;
-	#pending: Promise<void> = Promise.resolve();
 
 	readonly #allocateFilePath: () => string;
 	readonly #spillThreshold: number;
@@ -54,15 +52,16 @@ export class OutputSink {
 
 	async #pushSanitized(data: string): Promise<void> {
 		this.#onChunk?.(data);
-		const dataBytes = Buffer.byteLength(data);
-		const overflow = dataBytes + this.#bytesWritten > this.#spillThreshold || this.#file != null;
+
+		const bufferOverflow = data.length + this.#buffer.length > this.#spillThreshold;
+		const overflow = this.#file || bufferOverflow;
 
 		const sink = overflow ? await this.#fileSink() : null;
 
 		this.#buffer += data;
 		await sink?.write(data);
 
-		if (this.#buffer.length > this.#spillThreshold) {
+		if (bufferOverflow) {
 			this.#buffer = this.#buffer.slice(-this.#spillThreshold);
 		}
 	}
@@ -81,28 +80,21 @@ export class OutputSink {
 
 	async push(chunk: string): Promise<void> {
 		chunk = sanitizeText(chunk);
-		const op = this.#pending.then(() => this.#pushSanitized(chunk));
-		this.#pending = op.catch(() => {});
-		await op;
+		await this.#pushSanitized(chunk);
 	}
 
 	createInput(): WritableStream<Uint8Array | string> {
-		let decoder: TextDecoder | undefined;
-		let finalize = async () => {};
+		const dec = new TextDecoder("utf-8", { ignoreBOM: true });
+		const finalize = async () => {
+			await this.push(dec.decode());
+		};
 
 		return new WritableStream<Uint8Array | string>({
 			write: async (chunk) => {
 				if (typeof chunk === "string") {
 					await this.push(chunk);
 				} else {
-					if (!decoder) {
-						const dec = new TextDecoder("utf-8", { ignoreBOM: true });
-						decoder = dec;
-						finalize = async () => {
-							await this.push(dec.decode());
-						};
-					}
-					await this.push(decoder.decode(chunk, { stream: true }));
+					await this.push(dec.decode(chunk, { stream: true }));
 				}
 			},
 			close: finalize,
@@ -111,7 +103,6 @@ export class OutputSink {
 	}
 
 	async dump(notice?: string): Promise<OutputResult> {
-		await this.#pending;
 		const noticeLine = notice ? `[${notice}]\n` : "";
 
 		if (this.#file) {

package/src/core/tools/python.ts

@@ -40,7 +40,7 @@ function groupPreludeHelpers(helpers: PreludeHelper[]): PreludeCategory[] {
 
 export const pythonSchema = Type.Object({
 	code: Type.String({ description: "Python code to execute" }),
-	timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (optional, no default timeout)" })),
+	timeoutMs: Type.Optional(Type.Number({ description: "Timeout in milliseconds (default: 30000)" })),
 	workdir: Type.Optional(
 		Type.String({ description: "Working directory for the command (default: current directory)" }),
 	),
@@ -151,7 +151,7 @@ export class PythonTool implements AgentTool<typeof pythonSchema> {
 			throw new Error("Python tool requires a session when not using proxy executor");
 		}
 
-		const { code, timeout, workdir, reset } = params;
+		const { code, timeoutMs = 30000, workdir, reset } = params;
 		const controller = new AbortController();
 		const onAbort = () => controller.abort();
 		signal?.addEventListener("abort", onAbort, { once: true });
@@ -182,7 +182,7 @@ export class PythonTool implements AgentTool<typeof pythonSchema> {
 			const sessionId = sessionFile ? `session:${sessionFile}:workdir:${commandCwd}` : `cwd:${commandCwd}`;
 			const executorOptions: PythonExecutorOptions = {
 				cwd: commandCwd,
-				timeout: timeout ? timeout * 1000 : undefined,
+				timeoutMs,
 				signal: controller.signal,
 				sessionId,
 				kernelMode: this.session.settings?.getPythonKernelMode?.() ?? "session",