@xiaoso/dsh-tool-plus 0.1.0-beta.3 → 0.1.0-beta.4

package/lib/idle-iterator-Baoyn3Hp.mjs

@@ -0,0 +1,366 @@
+import { installBunShim as __installBunShim } from "./bun-shim.mjs";
+__installBunShim();
+import { P as $env } from "./src-lDmkSRbm.mjs";
+import { n as StreamTimeoutError, v as AbortError } from "./error-yCSG0mGC.mjs";
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/utils/idle-iterator.ts
+const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 3e5;
+const DEFAULT_STREAM_FIRST_EVENT_TIMEOUT_MS = 3e5;
+/** Re-mint persistent race promises every N iterations (see hoisted-racer comment). */
+const RACER_REMINT_INTERVAL = 1024;
+function normalizeIdleTimeoutMs(value, fallback) {
+	if (value === void 0) return fallback;
+	const parsed = Number(value);
+	if (!Number.isFinite(parsed)) return fallback;
+	if (parsed <= 0) return void 0;
+	return Math.trunc(parsed);
+}
+/**
+* Returns the idle timeout used for provider streaming transports.
+*
+* `PI_OPENAI_STREAM_IDLE_TIMEOUT_MS` is accepted as a backward-compatible alias.
+* Set `PI_STREAM_IDLE_TIMEOUT_MS=0` to disable the watchdog.
+*
+* Providers that legitimately stream much slower than the global default can pass
+* `fallbackMs` to widen the floor used when neither env var nor caller option is set.
+* Caller options still take precedence; env overrides still trump the fallback.
+*/
+function getStreamIdleTimeoutMs(fallbackMs = DEFAULT_STREAM_IDLE_TIMEOUT_MS) {
+	return normalizeIdleTimeoutMs($env.PI_STREAM_IDLE_TIMEOUT_MS ?? $env.PI_OPENAI_STREAM_IDLE_TIMEOUT_MS, fallbackMs);
+}
+/**
+* Returns the idle timeout used for OpenAI-family streaming transports.
+*
+* `PI_OPENAI_STREAM_IDLE_TIMEOUT_MS` takes precedence over the generic
+* `PI_STREAM_IDLE_TIMEOUT_MS` because some deployments tune OpenAI-compatible
+* backends separately from Anthropic/Gemini-style transports.
+*
+* Set `PI_OPENAI_STREAM_IDLE_TIMEOUT_MS=0` to disable the watchdog.
+*/
+function getOpenAIStreamIdleTimeoutMs(fallbackMs = DEFAULT_STREAM_IDLE_TIMEOUT_MS) {
+	return normalizeIdleTimeoutMs($env.PI_OPENAI_STREAM_IDLE_TIMEOUT_MS ?? $env.PI_STREAM_IDLE_TIMEOUT_MS, fallbackMs);
+}
+/**
+* Returns the timeout used while waiting for the first stream event.
+* The first token can legitimately take longer than later inter-event gaps,
+* so the default never undershoots the steady-state idle timeout.
+*
+* Set `PI_STREAM_FIRST_EVENT_TIMEOUT_MS=0` to disable the watchdog.
+*
+* Providers whose first response can legitimately take longer (heavy reasoning,
+* slow cold-start proxies) can pass `fallbackMs` to widen the floor used when
+* neither env var nor caller option is set. Caller options still take precedence;
+* env overrides still trump the fallback.
+*/
+function getStreamFirstEventTimeoutMs(idleTimeoutMs, fallbackMs = DEFAULT_STREAM_FIRST_EVENT_TIMEOUT_MS) {
+	const fallback = idleTimeoutMs === void 0 ? fallbackMs : Math.max(fallbackMs, idleTimeoutMs);
+	return normalizeIdleTimeoutMs($env.PI_STREAM_FIRST_EVENT_TIMEOUT_MS, fallback);
+}
+/**
+* Returns the first-event timeout used for OpenAI-family streaming transports.
+*
+* Precedence: explicit `PI_OPENAI_STREAM_FIRST_EVENT_TIMEOUT_MS` (including a
+* `"0"` disable) wins outright. Otherwise the resolved idle (caller-supplied
+* `idleTimeoutMs` — which itself already encompasses per-call
+* `streamIdleTimeoutMs` or `PI_OPENAI_STREAM_IDLE_TIMEOUT_MS` resolved
+* upstream) floors the first-event budget so slow OpenAI-compatible servers
+* are not undercut by a shorter `PI_STREAM_FIRST_EVENT_TIMEOUT_MS` or the
+* global default during prompt processing. A zero per-provider fallback
+* disables the first-event watchdog unless an environment override is set.
+*
+* Returns `0` when an explicit env knob or per-provider fallback disables the
+* watchdog, preserving the sentinel through iterator timeout resolution.
+*/
+function getOpenAIStreamFirstEventTimeoutMs(idleTimeoutMs, fallbackMs = DEFAULT_STREAM_FIRST_EVENT_TIMEOUT_MS) {
+	const openAIFirstEventRaw = $env.PI_OPENAI_STREAM_FIRST_EVENT_TIMEOUT_MS;
+	if (openAIFirstEventRaw !== void 0) return normalizeIdleTimeoutMs(openAIFirstEventRaw, fallbackMs) ?? 0;
+	const base = normalizeIdleTimeoutMs($env.PI_STREAM_FIRST_EVENT_TIMEOUT_MS, fallbackMs);
+	if (base === void 0 || base <= 0) return 0;
+	if (idleTimeoutMs === void 0 || idleTimeoutMs <= 0) return base;
+	return Math.max(base, idleTimeoutMs);
+}
+/**
+* Arms a clearable pre-response (time-to-first-byte) abort guard for a streaming
+* fetch, combined with the caller's signal.
+*
+* `AbortSignal.timeout(ms)` is an *absolute* wall-clock deadline: once handed to
+* `fetch` it keeps governing the request after the response headers arrive, so
+* it aborts an actively-streaming body the moment it fires — not just a stalled
+* pre-response request (issue #2422 regression: large `write` tool-call streams
+* died at the budget with `TimeoutError: The operation timed out.` despite
+* deltas actively flowing). This arms a `clearTimeout`-able timer instead;
+* callers MUST `clear()` as soon as the guarded transport attempt settles so
+* the body stream is left to the iterator-level idle watchdog.
+*
+* Retrying callers MUST arm a fresh guard for each transport attempt and keep
+* the retry loop's base signal reserved for caller cancellation. Reusing the
+* guard as the loop signal makes its timeout indistinguishable from cancellation.
+*
+* Returns the caller signal unchanged (and a no-op `clear`) when no positive
+* timeout is configured.
+*/
+function armPreResponseTimeout(callerSignal, timeoutMs) {
+	if (timeoutMs === void 0 || timeoutMs <= 0) return {
+		signal: callerSignal,
+		clear: () => {}
+	};
+	const controller = new AbortController();
+	const timer = setTimeout(() => {
+		controller.abort(new DOMException("The operation timed out.", "TimeoutError"));
+	}, timeoutMs);
+	timer.unref?.();
+	return {
+		signal: callerSignal ? AbortSignal.any([callerSignal, controller.signal]) : controller.signal,
+		clear: () => clearTimeout(timer)
+	};
+}
+/**
+* Yields items from an async iterable while enforcing a maximum idle gap between items.
+*
+* The first item may use a shorter timeout so stuck requests can be aborted and retried
+* before any user-visible content has streamed.
+*/
+async function* iterateWithIdleTimeout(iterable, options) {
+	const firstItemTimeoutMs = options.firstItemTimeoutMs ?? options.idleTimeoutMs;
+	let firstItemDeadlineMs = firstItemTimeoutMs !== void 0 && firstItemTimeoutMs > 0 ? Date.now() + firstItemTimeoutMs : void 0;
+	const abortSignal = options.abortSignal;
+	const iterator = iterable[Symbol.asyncIterator]();
+	let iteratorClosed = false;
+	const closeIterator = () => {
+		if (iteratorClosed) return;
+		iteratorClosed = true;
+		const returnPromise = iterator.return?.();
+		if (returnPromise) returnPromise.catch(() => {});
+	};
+	if (abortSignal?.aborted) {
+		closeIterator();
+		throw abortReason(abortSignal);
+	}
+	const withRacy = (promise) => promise.then((result) => ({
+		kind: "next",
+		result
+	}), (error) => ({
+		kind: "error",
+		error
+	}));
+	let awaitingFirstItem = true;
+	const markFirstItemReceived = () => {
+		awaitingFirstItem = false;
+	};
+	const isProgressItem = (item) => {
+		if (!options.isProgressItem) return true;
+		try {
+			return options.isProgressItem(item);
+		} catch {
+			return true;
+		}
+	};
+	let lastProgressAt = Date.now();
+	const hasPendingLocalWork = () => {
+		if (!options.hasPendingLocalWork) return false;
+		try {
+			return options.hasPendingLocalWork();
+		} catch {
+			return false;
+		}
+	};
+	const extendDeadlineForLocalWork = () => {
+		if (awaitingFirstItem) {
+			if (firstItemDeadlineMs !== void 0 && firstItemTimeoutMs !== void 0) firstItemDeadlineMs = Date.now() + firstItemTimeoutMs;
+		} else lastProgressAt = Date.now();
+	};
+	const noTimeoutEnforced = (firstItemTimeoutMs === void 0 || firstItemTimeoutMs <= 0) && (options.idleTimeoutMs === void 0 || options.idleTimeoutMs <= 0);
+	let abortPromise;
+	let abortListener;
+	let resolveAbort;
+	if (abortSignal) {
+		const { promise, resolve } = Promise.withResolvers();
+		resolveAbort = resolve;
+		abortListener = () => resolveAbort?.({ kind: "abort" });
+		abortSignal.addEventListener("abort", abortListener, { once: true });
+		abortPromise = promise;
+	}
+	let timeoutPromise;
+	let resolveTimeout;
+	let timeoutFired = false;
+	let timer;
+	let timerFireAtMs = Infinity;
+	const currentDeadlineMs = () => {
+		if (awaitingFirstItem) return firstItemDeadlineMs;
+		if (options.idleTimeoutMs !== void 0 && options.idleTimeoutMs > 0) return lastProgressAt + options.idleTimeoutMs;
+	};
+	const onTimerFire = () => {
+		timer = void 0;
+		timerFireAtMs = Infinity;
+		const deadlineMs = currentDeadlineMs();
+		if (deadlineMs === void 0) return;
+		const remainingMs = deadlineMs - Date.now();
+		if (remainingMs > 0) {
+			timerFireAtMs = deadlineMs;
+			timer = setTimeout(onTimerFire, remainingMs);
+			return;
+		}
+		timeoutFired = true;
+		resolveTimeout?.({ kind: "timeout" });
+	};
+	const armTimer = (deadlineMs) => {
+		if (timeoutPromise === void 0 || timeoutFired) {
+			const { promise, resolve } = Promise.withResolvers();
+			timeoutPromise = promise;
+			resolveTimeout = resolve;
+			timeoutFired = false;
+		}
+		if (timer !== void 0) {
+			if (timerFireAtMs <= deadlineMs) return;
+			clearTimeout(timer);
+		}
+		timerFireAtMs = deadlineMs;
+		timer = setTimeout(onTimerFire, Math.max(0, deadlineMs - Date.now()));
+	};
+	let pendingNext;
+	try {
+		let raceCount = 0;
+		while (true) {
+			if (++raceCount % RACER_REMINT_INTERVAL === 0) {
+				if (abortPromise !== void 0 && !abortSignal.aborted) {
+					const { promise, resolve } = Promise.withResolvers();
+					resolveAbort = resolve;
+					abortPromise = promise;
+				}
+				if (timeoutPromise !== void 0 && !timeoutFired) {
+					const { promise, resolve } = Promise.withResolvers();
+					resolveTimeout = resolve;
+					timeoutPromise = promise;
+				}
+			}
+			let activeTimeoutMs;
+			if (awaitingFirstItem) {
+				if (firstItemDeadlineMs !== void 0) {
+					activeTimeoutMs = firstItemDeadlineMs - Date.now();
+					if (activeTimeoutMs <= 0) {
+						if (!hasPendingLocalWork()) {
+							options.onFirstItemTimeout?.();
+							closeIterator();
+							throw new StreamTimeoutError(options.firstItemErrorMessage ?? options.errorMessage);
+						}
+						extendDeadlineForLocalWork();
+						activeTimeoutMs = firstItemDeadlineMs - Date.now();
+					}
+				}
+			} else if (options.idleTimeoutMs !== void 0 && options.idleTimeoutMs > 0) {
+				activeTimeoutMs = options.idleTimeoutMs - (Date.now() - lastProgressAt);
+				if (activeTimeoutMs <= 0) {
+					if (!hasPendingLocalWork()) {
+						options.onIdle?.();
+						closeIterator();
+						throw new StreamTimeoutError(options.errorMessage);
+					}
+					extendDeadlineForLocalWork();
+					activeTimeoutMs = options.idleTimeoutMs;
+				}
+			}
+			pendingNext ??= withRacy(iterator.next());
+			const racers = [pendingNext];
+			if (!noTimeoutEnforced && activeTimeoutMs !== void 0 && activeTimeoutMs > 0) {
+				armTimer(Date.now() + activeTimeoutMs);
+				racers.push(timeoutPromise);
+			}
+			if (abortPromise) racers.push(abortPromise);
+			let continuing = false;
+			try {
+				const outcome = await Promise.race(racers);
+				if (outcome.kind === "next" || outcome.kind === "error") pendingNext = void 0;
+				if (outcome.kind === "abort") {
+					closeIterator();
+					throw abortReason(abortSignal);
+				}
+				if (outcome.kind === "timeout") {
+					if (hasPendingLocalWork()) {
+						extendDeadlineForLocalWork();
+						continuing = true;
+						continue;
+					}
+					if (!awaitingFirstItem) options.onIdle?.();
+					else options.onFirstItemTimeout?.();
+					closeIterator();
+					throw new StreamTimeoutError(!awaitingFirstItem ? options.errorMessage : options.firstItemErrorMessage ?? options.errorMessage);
+				}
+				if (outcome.kind === "error") throw outcome.error;
+				if (outcome.result.done) {
+					markFirstItemReceived();
+					return;
+				}
+				const item = outcome.result.value;
+				if (isProgressItem(item)) {
+					markFirstItemReceived();
+					lastProgressAt = Date.now();
+				}
+				yield item;
+				continuing = true;
+			} finally {
+				if (!continuing) closeIterator();
+			}
+		}
+	} finally {
+		if (timer !== void 0) clearTimeout(timer);
+		resolveTimeout?.({ kind: "timeout" });
+		if (abortListener && abortSignal) abortSignal.removeEventListener("abort", abortListener);
+		resolveAbort?.({ kind: "abort" });
+	}
+}
+/**
+* Yields items from an async iterable until the consumer marks the stream
+* logically finished AND the source stays silent past a short grace window.
+*
+* Misbehaving OpenAI-compatible servers deliver the terminal chunk but never
+* send `[DONE]` nor close the connection; without this guard the consumer
+* hangs on `iterator.next()` until the idle watchdog converts an
+* already-successful turn into a timeout error. Grace expiry is a clean end
+* of iteration, never an error.
+*/
+async function* iterateWithTerminalGrace(iterable, options) {
+	const iterator = iterable[Symbol.asyncIterator]();
+	try {
+		while (true) {
+			const finishedAtMs = options.finishedAtMs();
+			if (finishedAtMs === void 0) {
+				const result = await iterator.next();
+				if (result.done) return;
+				yield result.value;
+				continue;
+			}
+			const remainingMs = finishedAtMs + options.graceMs - Date.now();
+			if (remainingMs <= 0) {
+				options.onGraceEnd?.();
+				return;
+			}
+			const nextPromise = iterator.next();
+			let timer;
+			const timeoutPromise = new Promise((resolve) => {
+				timer = setTimeout(() => resolve("timeout"), remainingMs);
+			});
+			try {
+				const outcome = await Promise.race([nextPromise, timeoutPromise]);
+				if (outcome === "timeout") {
+					nextPromise.catch(() => {});
+					options.onGraceEnd?.();
+					return;
+				}
+				if (outcome.done) return;
+				yield outcome.value;
+			} finally {
+				if (timer !== void 0) clearTimeout(timer);
+			}
+		}
+	} finally {
+		const returnPromise = iterator.return?.();
+		if (returnPromise) Promise.resolve(returnPromise).catch(() => {});
+	}
+}
+function abortReason(signal) {
+	const reason = signal.reason;
+	if (reason instanceof Error) return reason;
+	if (typeof reason === "string") return new AbortError(reason);
+	return new AbortError();
+}
+//#endregion
+export { getStreamIdleTimeoutMs as a, getStreamFirstEventTimeoutMs as i, getOpenAIStreamFirstEventTimeoutMs as n, iterateWithIdleTimeout as o, getOpenAIStreamIdleTimeoutMs as r, iterateWithTerminalGrace as s, armPreResponseTimeout as t };