@oh-my-pi/pi-utils 18.2.2 → 18.2.4

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## [Unreleased]
 
+## [18.2.3] - 2026-09-17
+
+### Fixed
+
+- Optimized model configuration command execution by deduplicating requests and adding failure backoff
+- Prevented unnecessary credential command execution when runtime API keys are configured
+- Retained `readLines()` results no longer change when later chunks reuse the internal buffer.
+- Long sleeps honor elapsed time and re-arm after premature timer wakes without overflowing native timer delays.
+
 ## [18.2.2] - 2026-09-16
 
 ### Added

package/dist/types/async.d.ts

@@ -12,15 +12,8 @@ export declare const MAX_TIMER_DELAY_MS = 2147483647;
  * so no single timer overflows; an abort during any chunk rejects like
  * `scheduler.wait`.
  *
- * The remainder is deliberately consumed by chunk, not recomputed from a
- * monotonic deadline: deadline tracking never terminates under the repo's
- * instant `scheduler.wait` mocks (retry-cap suites spy it to resolve
- * immediately, so `deadline - performance.now()` never reaches zero and the
- * loop spins forever). A premature native wake (Bun `uv_async_send`, see
- * `sleepAtLeast` in `packages/agent/src/utils/yield.ts`) can therefore
- * under-wait by the unelapsed chunk time — but that self-corrects downstream:
- * credential blocks carry the true deadline independently of this sleep, so
- * an early retry re-hits 429 and re-sleeps on a fresh server hint.
+ * Uses a monotonic deadline so a timer that wakes prematurely is re-armed for
+ * the unelapsed duration instead of shortening the requested sleep.
  */
 export declare function sleepLong(delayMs: number, signal?: AbortSignal): Promise<void>;
 /**

package/dist/types/stream.d.ts

@@ -1,3 +1,9 @@
+/**
+ * Split a byte stream on LF boundaries.
+ *
+ * Every yielded line owns its bytes and remains unchanged after the generator
+ * advances or drains. Line terminators are excluded.
+ */
 export declare function readLines(stream: ReadableStream<Uint8Array>, signal?: AbortSignal): AsyncGenerator<Uint8Array>;
 export declare function readJsonl<T>(stream: ReadableStream<Uint8Array>, signal?: AbortSignal): AsyncGenerator<T>;
 /**
@@ -22,7 +28,13 @@ export declare class ConcatSink {
     /** Drop the first `count` buffered bytes, keeping the remainder. */
     consume(count: number): void;
     clear(): void;
-    appendAndFlushLines(chunk: Uint8Array): Generator<Uint8Array<ArrayBufferLike>, void, unknown>;
+    /**
+     * Append a chunk and yield each complete LF-delimited line.
+     *
+     * Yielded lines are owned snapshots. Unlike {@link flush}, they remain
+     * valid after this sink or the input chunk is mutated.
+     */
+    appendAndFlushLines(chunk: Uint8Array): Generator<Uint8Array>;
     appendAndFlushText(chunk: Uint8Array, decoder: TextDecoder): string | undefined;
     pullJSONL<T>(chunk: Uint8Array, beg: number, end: number): Generator<T, void, unknown>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-utils",
-	"version": "18.2.2",
+	"version": "18.2.4",
 	"description": "Shared utilities for pi packages",
 	"keywords": [
 		"cli",
@@ -54,7 +54,7 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-natives": "18.2.2"
+		"@oh-my-pi/pi-natives": "18.2.4"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"

package/src/async.ts

@@ -15,22 +15,16 @@ export const MAX_TIMER_DELAY_MS = 2_147_483_647;
  * so no single timer overflows; an abort during any chunk rejects like
  * `scheduler.wait`.
  *
- * The remainder is deliberately consumed by chunk, not recomputed from a
- * monotonic deadline: deadline tracking never terminates under the repo's
- * instant `scheduler.wait` mocks (retry-cap suites spy it to resolve
- * immediately, so `deadline - performance.now()` never reaches zero and the
- * loop spins forever). A premature native wake (Bun `uv_async_send`, see
- * `sleepAtLeast` in `packages/agent/src/utils/yield.ts`) can therefore
- * under-wait by the unelapsed chunk time — but that self-corrects downstream:
- * credential blocks carry the true deadline independently of this sleep, so
- * an early retry re-hits 429 and re-sleeps on a fresh server hint.
+ * Uses a monotonic deadline so a timer that wakes prematurely is re-armed for
+ * the unelapsed duration instead of shortening the requested sleep.
  */
 export async function sleepLong(delayMs: number, signal?: AbortSignal): Promise<void> {
 	signal?.throwIfAborted();
-	let remaining = delayMs;
-	while (remaining > 0) {
+	const deadline = performance.now() + delayMs;
+	while (true) {
+		const remaining = deadline - performance.now();
+		if (!(remaining > 0)) return;
 		await scheduler.wait(Math.min(remaining, MAX_TIMER_DELAY_MS), { signal });
-		remaining -= MAX_TIMER_DELAY_MS;
 		signal?.throwIfAborted();
 	}
 }

package/src/stream.ts

@@ -6,6 +6,12 @@ import { parseStreamingJson } from "./json-parse";
 const LF = 0x0a;
 const CR = 0x0d;
 
+/**
+ * Split a byte stream on LF boundaries.
+ *
+ * Every yielded line owns its bytes and remains unchanged after the generator
+ * advances or drains. Line terminators are excluded.
+ */
 export async function* readLines(stream: ReadableStream<Uint8Array>, signal?: AbortSignal): AsyncGenerator<Uint8Array> {
 	const buffer = new ConcatSink();
 	const source = abortableSource(stream, signal);
@@ -131,7 +137,13 @@ export class ConcatSink {
 		this.#length = 0;
 	}
 
-	*appendAndFlushLines(chunk: Uint8Array) {
+	/**
+	 * Append a chunk and yield each complete LF-delimited line.
+	 *
+	 * Yielded lines are owned snapshots. Unlike {@link flush}, they remain
+	 * valid after this sink or the input chunk is mutated.
+	 */
+	*appendAndFlushLines(chunk: Uint8Array): Generator<Uint8Array> {
 		let pos = 0;
 		while (pos < chunk.length) {
 			const nl = chunk.indexOf(LF, pos);
@@ -142,12 +154,12 @@ export class ConcatSink {
 			const suffix = chunk.subarray(pos, nl);
 			pos = nl + 1;
 			if (this.isEmpty) {
-				yield suffix;
+				yield new Uint8Array(suffix);
 			} else {
 				this.append(suffix);
 				const payload = this.flush();
 				if (payload) {
-					yield payload;
+					yield new Uint8Array(payload);
 					this.clear();
 				}
 			}