@oh-my-pi/pi-ai 14.7.2 → 14.7.4

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "14.7.2",
+	"version": "14.7.4",
 	"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.39",
 		"@bufbuild/protobuf": "^2.12.0",
 		"@google/genai": "^1.52.0",
-		"@oh-my-pi/pi-natives": "14.7.2",
-		"@oh-my-pi/pi-utils": "14.7.2",
+		"@oh-my-pi/pi-natives": "14.7.4",
+		"@oh-my-pi/pi-utils": "14.7.4",
 		"@sinclair/typebox": "^0.34.49",
 		"@smithy/node-http-handler": "^4.6.1",
 		"ajv": "^8.20.0",

package/src/providers/anthropic.ts

@@ -8,7 +8,7 @@ import type {
 	MessageParam,
 	RawMessageStreamEvent,
 } from "@anthropic-ai/sdk/resources/messages";
-import { $env, abortableSleep, isEnoent } from "@oh-my-pi/pi-utils";
+import { $env, abortableSleep, isEnoent, readSseEvents } from "@oh-my-pi/pi-utils";
 import { hasOpus47ApiRestrictions, mapEffortToAnthropicAdaptiveEffort } from "../model-thinking";
 import { calculateCost } from "../models";
 import { getEnvApiKey, OUTPUT_FALLBACK_BUFFER } from "../stream";
@@ -658,18 +658,6 @@ function mergeHeaders(...headerSources: (Record<string, string> | undefined)[]):
 // We surface the resulting provider error ourselves, so keep the SDK quiet.
 const ANTHROPIC_SDK_LOG_LEVEL = "off" as const;
 
-interface ServerSentEvent {
-	event: string | null;
-	data: string;
-	raw: string[];
-}
-
-interface SseDecoderState {
-	event: string | null;
-	data: string[];
-	raw: string[];
-}
-
 const ANTHROPIC_MESSAGE_EVENTS: ReadonlySet<string> = new Set([
 	"message_start",
 	"message_delta",
@@ -679,136 +667,6 @@ const ANTHROPIC_MESSAGE_EVENTS: ReadonlySet<string> = new Set([
 	"content_block_stop",
 ]);
 
-function flushSseEvent(state: SseDecoderState): ServerSentEvent | null {
-	if (!state.event && state.data.length === 0) {
-		return null;
-	}
-
-	const event: ServerSentEvent = {
-		event: state.event,
-		data: state.data.join("\n"),
-		raw: [...state.raw],
-	};
-	state.event = null;
-	state.data = [];
-	state.raw = [];
-	return event;
-}
-
-function decodeSseLine(line: string, state: SseDecoderState): ServerSentEvent | null {
-	if (line === "") {
-		return flushSseEvent(state);
-	}
-
-	state.raw.push(line);
-	if (line.startsWith(":")) {
-		return null;
-	}
-
-	const delimiterIndex = line.indexOf(":");
-	const fieldName = delimiterIndex === -1 ? line : line.slice(0, delimiterIndex);
-	let value = delimiterIndex === -1 ? "" : line.slice(delimiterIndex + 1);
-	if (value.startsWith(" ")) {
-		value = value.slice(1);
-	}
-
-	if (fieldName === "event") {
-		state.event = value;
-	} else if (fieldName === "data") {
-		state.data.push(value);
-	}
-
-	return null;
-}
-
-function nextLineBreakIndex(text: string): number {
-	const carriageReturnIndex = text.indexOf("\r");
-	const newlineIndex = text.indexOf("\n");
-	if (carriageReturnIndex === -1) {
-		return newlineIndex;
-	}
-	if (newlineIndex === -1) {
-		return carriageReturnIndex;
-	}
-	return Math.min(carriageReturnIndex, newlineIndex);
-}
-
-function consumeLine(text: string): { line: string; rest: string } | null {
-	const lineBreakIndex = nextLineBreakIndex(text);
-	if (lineBreakIndex === -1) {
-		return null;
-	}
-
-	let nextIndex = lineBreakIndex + 1;
-	if (text[lineBreakIndex] === "\r" && text[nextIndex] === "\n") {
-		nextIndex += 1;
-	}
-
-	return {
-		line: text.slice(0, lineBreakIndex),
-		rest: text.slice(nextIndex),
-	};
-}
-
-async function* iterateSseMessages(
-	body: ReadableStream<Uint8Array>,
-	signal?: AbortSignal,
-): AsyncGenerator<ServerSentEvent> {
-	const reader = body.getReader();
-	const decoder = new TextDecoder();
-	const state: SseDecoderState = { event: null, data: [], raw: [] };
-	let buffer = "";
-
-	try {
-		while (true) {
-			if (signal?.aborted) {
-				throw new Error("Request was aborted");
-			}
-
-			const { value, done } = await reader.read();
-			if (done) {
-				break;
-			}
-
-			buffer += decoder.decode(value, { stream: true });
-			let consumed = consumeLine(buffer);
-			while (consumed) {
-				buffer = consumed.rest;
-				const event = decodeSseLine(consumed.line, state);
-				if (event) {
-					yield event;
-				}
-				consumed = consumeLine(buffer);
-			}
-		}
-
-		buffer += decoder.decode();
-		let consumed = consumeLine(buffer);
-		while (consumed) {
-			buffer = consumed.rest;
-			const event = decodeSseLine(consumed.line, state);
-			if (event) {
-				yield event;
-			}
-			consumed = consumeLine(buffer);
-		}
-
-		if (buffer.length > 0) {
-			const event = decodeSseLine(buffer, state);
-			if (event) {
-				yield event;
-			}
-		}
-
-		const trailingEvent = flushSseEvent(state);
-		if (trailingEvent) {
-			yield trailingEvent;
-		}
-	} finally {
-		reader.releaseLock();
-	}
-}
-
 async function* iterateAnthropicEvents(
 	response: Response,
 	signal?: AbortSignal,
@@ -820,7 +678,7 @@ async function* iterateAnthropicEvents(
 	let sawMessageStart = false;
 	let sawMessageEnd = false;
 
-	for await (const sse of iterateSseMessages(response.body, signal)) {
+	for await (const sse of readSseEvents(response.body, signal)) {
 		if (sse.event === "error") {
 			throw new Error(sse.data);
 		}

package/src/utils/event-stream.ts

@@ -105,23 +105,7 @@ export class EventStream<T, R = T> implements AsyncIterable<T> {
 	}
 }
 
-// Delta events that can be batched for throttling
-type DeltaEvent =
-	| { type: "text_delta"; contentIndex: number; delta: string; partial: AssistantMessage }
-	| { type: "thinking_delta"; contentIndex: number; delta: string; partial: AssistantMessage }
-	| { type: "toolcall_delta"; contentIndex: number; delta: string; partial: AssistantMessage };
-
-function isDeltaEvent(event: AssistantMessageEvent): event is DeltaEvent {
-	return event.type === "text_delta" || event.type === "thinking_delta" || event.type === "toolcall_delta";
-}
-
 export class AssistantMessageEventStream extends EventStream<AssistantMessageEvent, AssistantMessage> {
-	// Throttling state
-	#deltaBuffer: DeltaEvent[] = [];
-	#flushTimer?: NodeJS.Timeout;
-	#lastFlushTime = 0;
-	readonly #throttleMs = 50; // 20 updates/sec
-
 	constructor() {
 		super(
 			event => event.type === "done" || event.type === "error",
@@ -139,103 +123,20 @@ export class AssistantMessageEventStream extends EventStream<AssistantMessageEve
 	override push(event: AssistantMessageEvent): void {
 		if (this.done) return;
 
-		// Check for completion first
+		// Completion resolves the final result and still emits the terminal event.
 		if (this.isComplete(event)) {
-			this.#flushDeltas(); // Flush any pending deltas before completing
 			this.done = true;
 			this.resolveFinalResult(this.extractResult(event));
 		}
 
-		// Delta events get batched and throttled
-		if (isDeltaEvent(event)) {
-			this.#deltaBuffer.push(event);
-			this.#scheduleFlush();
-			return;
-		}
-
-		// Non-delta events flush pending deltas immediately, then emit
-		this.#flushDeltas();
 		this.deliver(event);
 	}
 
 	override end(result?: AssistantMessage): void {
-		this.#flushDeltas();
 		this.done = true;
 		if (result !== undefined) {
 			this.resolveFinalResult(result);
 		}
 		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
-
-		const now = Bun.nanoseconds();
-		const timeSinceLastFlush = (now - this.#lastFlushTime) / 1e6;
-
-		if (timeSinceLastFlush >= this.#throttleMs) {
-			// Flush immediately if throttle window has passed
-			this.#flushDeltas();
-		} else {
-			// Schedule flush for when throttle window expires
-			const delay = this.#throttleMs - timeSinceLastFlush;
-			this.#flushTimer = setTimeout(() => {
-				this.#flushTimer = undefined;
-				this.#flushDeltas();
-			}, delay);
-		}
-	}
-
-	#flushDeltas(): void {
-		if (this.#flushTimer) {
-			clearTimeout(this.#flushTimer);
-			this.#flushTimer = undefined;
-		}
-
-		if (this.#deltaBuffer.length === 0) return;
-
-		// Merge consecutive deltas for the same content block and type
-		const merged = this.#mergeDeltas(this.#deltaBuffer);
-		this.#deltaBuffer = [];
-		this.#lastFlushTime = Bun.nanoseconds();
-
-		for (const event of merged) {
-			this.deliver(event);
-		}
-	}
-
-	#mergeDeltas(deltas: DeltaEvent[]): AssistantMessageEvent[] {
-		if (deltas.length === 0) return [];
-		if (deltas.length === 1) return [deltas[0]];
-
-		const result: AssistantMessageEvent[] = [];
-		let current = deltas[0];
-
-		for (let i = 1; i < deltas.length; i++) {
-			const next = deltas[i];
-			// Can merge if same type, same content index
-			if (next.type === current.type && next.contentIndex === current.contentIndex) {
-				current = {
-					...current,
-					delta: current.delta + next.delta,
-					partial: next.partial, // Use latest partial
-				} as DeltaEvent;
-			} else {
-				result.push(current);
-				current = next;
-			}
-		}
-		result.push(current);
-
-		return result;
-	}
 }