@oh-my-pi/pi-ai 14.6.1 → 14.6.2

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## [Unreleased]
 
+## [14.6.2] - 2026-05-03
+### Added
+
+- Added `EventStream.fail(err)` method to terminate the async iterator with an error, enabling consumers to catch stream-level failures via `for await` without hanging
+
+### Fixed
+
+- Fixed OpenAI Responses tool schema conversion to rewrite non-strict `oneOf` unions to `anyOf` before sending tools to the Responses API ([#920](https://github.com/can1357/oh-my-pi/issues/920))
+
 ## [14.6.0] - 2026-05-02
 
 ### Added

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "14.6.1",
+	"version": "14.6.2",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -46,8 +46,8 @@
 		"@aws-sdk/credential-provider-node": "^3.972.36",
 		"@bufbuild/protobuf": "^2.12.0",
 		"@google/genai": "^1.50.1",
-		"@oh-my-pi/pi-natives": "14.6.1",
-		"@oh-my-pi/pi-utils": "14.6.1",
+		"@oh-my-pi/pi-natives": "14.6.2",
+		"@oh-my-pi/pi-utils": "14.6.2",
 		"@sinclair/typebox": "^0.34.49",
 		"@smithy/node-http-handler": "^4.6.1",
 		"ajv": "^8.20.0",

package/src/providers/openai-responses.ts

@@ -40,7 +40,7 @@ import {
 import { parseGitHubCopilotApiKey } from "../utils/oauth/github-copilot";
 import { notifyProviderResponse } from "../utils/provider-response";
 import { callWithCopilotModelRetry } from "../utils/retry";
-import { adaptSchemaForStrict, NO_STRICT } from "../utils/schema";
+import { adaptSchemaForStrict, NO_STRICT, sanitizeSchemaForOpenAIResponses } from "../utils/schema";
 import { mapToOpenAIResponsesToolChoice, type OpenAIResponsesToolChoice } from "../utils/tool-choice";
 import {
 	buildCopilotDynamicHeaders,
@@ -592,7 +592,8 @@ export function convertTools(tools: Tool[], strictMode: boolean, model: Model<"o
 		}
 		const strict = !NO_STRICT && strictMode && tool.strict !== false;
 		const baseParameters = tool.parameters as unknown as Record<string, unknown>;
-		const { schema: parameters, strict: effectiveStrict } = adaptSchemaForStrict(baseParameters, strict);
+		const responseParameters = sanitizeSchemaForOpenAIResponses(baseParameters);
+		const { schema: parameters, strict: effectiveStrict } = adaptSchemaForStrict(responseParameters, strict);
 		return {
 			type: "function",
 			name: tool.name,

package/src/utils/event-stream.ts

@@ -3,17 +3,24 @@ import type { AssistantMessage, AssistantMessageEvent } from "../types";
 // Generic event stream class for async iteration
 export class EventStream<T, R = T> implements AsyncIterable<T> {
 	queue: T[] = [];
-	waiting: ((value: IteratorResult<T>) => void)[] = [];
+	waiting: Array<{ resolve: (value: IteratorResult<T>) => void; reject: (err: unknown) => void }> = [];
 	done = false;
+	#failed = false;
+	#error: unknown = undefined;
 	finalResultPromise: Promise<R>;
 	resolveFinalResult!: (result: R) => void;
+	rejectFinalResult!: (err: unknown) => void;
 	isComplete: (event: T) => boolean;
 	extractResult: (event: T) => R;
 
 	constructor(isComplete: (event: T) => boolean, extractResult: (event: T) => R) {
-		const { promise, resolve } = Promise.withResolvers<R>();
+		const { promise, resolve, reject } = Promise.withResolvers<R>();
+		// Prevent an unhandled rejection when fail() is called but nobody awaits result().
+		// Callers who do await result() still receive the rejection normally.
+		promise.catch(() => {});
 		this.finalResultPromise = promise;
 		this.resolveFinalResult = resolve;
+		this.rejectFinalResult = reject;
 		this.isComplete = isComplete;
 		this.extractResult = extractResult;
 	}
@@ -29,7 +36,7 @@ export class EventStream<T, R = T> implements AsyncIterable<T> {
 		// Deliver to waiting consumer or queue it
 		const waiter = this.waiting.shift();
 		if (waiter) {
-			waiter({ value: event, done: false });
+			waiter.resolve({ value: event, done: false });
 		} else {
 			this.queue.push(event);
 		}
@@ -38,7 +45,7 @@ export class EventStream<T, R = T> implements AsyncIterable<T> {
 	deliver(event: T): void {
 		const waiter = this.waiting.shift();
 		if (waiter) {
-			waiter({ value: event, done: false });
+			waiter.resolve({ value: event, done: false });
 		} else {
 			this.queue.push(event);
 		}
@@ -52,14 +59,26 @@ export class EventStream<T, R = T> implements AsyncIterable<T> {
 		// Notify all waiting consumers that we're done
 		while (this.waiting.length > 0) {
 			const waiter = this.waiting.shift()!;
-			waiter({ value: undefined as any, done: true });
+			waiter.resolve({ value: undefined as any, done: true });
 		}
 	}
 
 	endWaiting(): void {
 		while (this.waiting.length > 0) {
 			const waiter = this.waiting.shift()!;
-			waiter({ value: undefined as any, done: true });
+			waiter.resolve({ value: undefined as any, done: true });
+		}
+	}
+
+	fail(err: unknown): void {
+		if (this.done) return;
+		this.done = true;
+		this.#failed = true;
+		this.#error = err;
+		this.rejectFinalResult(err);
+		while (this.waiting.length > 0) {
+			const waiter = this.waiting.shift()!;
+			waiter.reject(err);
 		}
 	}
 
@@ -67,10 +86,14 @@ export class EventStream<T, R = T> implements AsyncIterable<T> {
 		while (true) {
 			if (this.queue.length > 0) {
 				yield this.queue.shift()!;
+			} else if (this.#failed) {
+				throw this.#error;
 			} else if (this.done) {
 				return;
 			} else {
-				const result = await new Promise<IteratorResult<T>>(resolve => this.waiting.push(resolve));
+				const result = await new Promise<IteratorResult<T>>((resolve, reject) =>
+					this.waiting.push({ resolve, reject }),
+				);
 				if (result.done) return;
 				yield result.value;
 			}
@@ -144,6 +167,15 @@ export class AssistantMessageEventStream extends EventStream<AssistantMessageEve
 		this.endWaiting();
 	}
 
+	override fail(err: unknown): void {
+		if (this.#flushTimer) {
+			clearTimeout(this.#flushTimer);
+			this.#flushTimer = undefined;
+		}
+		this.#deltaBuffer = [];
+		super.fail(err);
+	}
+
 	#scheduleFlush(): void {
 		if (this.#flushTimer) return; // Already scheduled
 

package/src/utils/schema/adapt.ts

@@ -1,4 +1,5 @@
 import { tryEnforceStrictSchema } from "./strict-mode";
+import type { JsonObject } from "./types";
 /**
  * Consolidated helper for OpenAI-style strict schema enforcement.
  *
@@ -18,3 +19,51 @@ export function adaptSchemaForStrict(
 
 	return tryEnforceStrictSchema(schema);
 }
+
+/**
+ * OpenAI Responses rejects `oneOf` in tool schemas even when strict mode is
+ * disabled. Non-strict schemas can still use `anyOf`, so preserve the union
+ * shape by recursively rewriting `oneOf` branches to `anyOf`.
+ */
+export function sanitizeSchemaForOpenAIResponses(schema: JsonObject): JsonObject {
+	return rewriteOneOfToAnyOf(schema) as JsonObject;
+}
+
+function rewriteOneOfToAnyOf(value: unknown): unknown {
+	if (Array.isArray(value)) {
+		let changed = false;
+		const rewritten = value.map(item => {
+			const next = rewriteOneOfToAnyOf(item);
+			if (next !== item) changed = true;
+			return next;
+		});
+		return changed ? rewritten : value;
+	}
+
+	if (!value || typeof value !== "object") {
+		return value;
+	}
+
+	const input = value as Record<string, unknown>;
+	let changed = false;
+	const output: Record<string, unknown> = {};
+	for (const [key, child] of Object.entries(input)) {
+		if (key === "oneOf") {
+			changed = true;
+			continue;
+		}
+		const next = rewriteOneOfToAnyOf(child);
+		if (next !== child) changed = true;
+		output[key] = next;
+	}
+
+	if (Array.isArray(input.oneOf)) {
+		const rewrittenOneOf = rewriteOneOfToAnyOf(input.oneOf);
+		const existingAnyOf = output.anyOf;
+		output.anyOf = Array.isArray(existingAnyOf)
+			? [...existingAnyOf, ...(rewrittenOneOf as unknown[])]
+			: rewrittenOneOf;
+	}
+
+	return changed ? output : value;
+}