@openclaw/ai 0.0.0 → 2026.7.1-2

package/dist/stream-first-event-timeout-RjWszj8c.mjs

@@ -0,0 +1,106 @@
+//#region packages/normalization-core/src/number-coercion.ts
+/** Returns a number only when the input is already finite. */
+function asFiniteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+/** Conservative upper bound for Node timer delays. */
+const MAX_TIMER_TIMEOUT_MS = 2147e6;
+/** Clamps finite millisecond values into the Node-safe timer range. */
+function clampTimerTimeoutMs(valueMs, minMs = 1) {
+	const value = asFiniteNumber(valueMs);
+	if (value === void 0) return;
+	return Math.min(Math.max(Math.floor(value), Math.max(1, Math.floor(minMs))), MAX_TIMER_TIMEOUT_MS);
+}
+/** Resolves arbitrary timeout input with fallback and minimum timer bounds. */
+function resolveTimerTimeoutMs(valueMs, fallbackMs, minMs = 1) {
+	const value = asFiniteNumber(valueMs) ?? asFiniteNumber(fallbackMs);
+	const min = Math.max(0, Math.floor(minMs));
+	if (value === void 0) return min;
+	return Math.min(Math.max(Math.floor(value), min), MAX_TIMER_TIMEOUT_MS);
+}
+//#endregion
+//#region packages/ai/src/utils/stream-first-event-timeout.ts
+function getFirstStreamEventTimeoutMs(options) {
+	return options?.firstEventTimeoutMs;
+}
+function getFirstStreamEventTimeoutHandler(options) {
+	return options?.onFirstEventTimeout;
+}
+function formatOptionalField(name, value) {
+	return value ? ` ${name}=${value}` : "";
+}
+function createFirstStreamEventTimeoutError(context) {
+	const stage = context.stage ? `${context.stage} ` : "";
+	const details = [
+		formatOptionalField("provider", context.provider),
+		formatOptionalField("api", context.api),
+		formatOptionalField("model", context.model)
+	].join("");
+	return /* @__PURE__ */ new Error(`${stage}HTTP stream opened but did not deliver a first SSE event within ${context.timeoutMs}ms after streaming headers (first-event timeout).${details}` + (context.hint ? ` ${context.hint}` : ""));
+}
+function createFirstStreamEventAbortController(parentSignal) {
+	const controller = new AbortController();
+	const abortFromParent = () => {
+		if (!controller.signal.aborted) controller.abort(parentSignal?.reason);
+	};
+	if (parentSignal?.aborted) abortFromParent();
+	else parentSignal?.addEventListener("abort", abortFromParent, { once: true });
+	return {
+		signal: controller.signal,
+		abort(reason) {
+			if (!controller.signal.aborted) controller.abort(reason);
+		},
+		dispose() {
+			parentSignal?.removeEventListener("abort", abortFromParent);
+		}
+	};
+}
+function withFirstStreamEventTimeout(stream, context) {
+	const timeoutMs = clampTimerTimeoutMs(context.timeoutMs);
+	if (timeoutMs === void 0 || context.timeoutMs <= 0) return stream;
+	const timeoutContext = {
+		...context,
+		timeoutMs
+	};
+	return { async *[Symbol.asyncIterator]() {
+		const iterator = stream[Symbol.asyncIterator]();
+		let timer;
+		let completed = false;
+		const clear = () => {
+			if (timer) {
+				clearTimeout(timer);
+				timer = void 0;
+			}
+		};
+		try {
+			const first = await new Promise((resolve, reject) => {
+				timer = setTimeout(() => {
+					const timeoutError = createFirstStreamEventTimeoutError(timeoutContext);
+					timeoutContext.onTimeout?.(timeoutError);
+					timeoutContext.abort?.(timeoutError);
+					reject(timeoutError);
+				}, timeoutMs);
+				timer.unref?.();
+				iterator.next().then(resolve, reject);
+			}).finally(clear);
+			if (first.done) {
+				completed = true;
+				return;
+			}
+			yield first.value;
+			for (;;) {
+				const next = await iterator.next();
+				if (next.done) {
+					completed = true;
+					return;
+				}
+				yield next.value;
+			}
+		} finally {
+			clear();
+			if (!completed) iterator.return?.().catch(() => void 0);
+		}
+	} };
+}
+//#endregion
+export { withFirstStreamEventTimeout as a, getFirstStreamEventTimeoutMs as i, createFirstStreamEventTimeoutError as n, clampTimerTimeoutMs as o, getFirstStreamEventTimeoutHandler as r, resolveTimerTimeoutMs as s, createFirstStreamEventAbortController as t };

package/dist/streaming-byte-guard-BrbkbwUu.mjs

@@ -0,0 +1,46 @@
+//#region packages/ai/src/utils/streaming-byte-guard.ts
+function createSseByteGuard(reader, opts) {
+	if (!Number.isFinite(opts.maxBytes) || opts.maxBytes < 0) throw new RangeError(`maxBytes must be a non-negative finite number: ${opts.maxBytes}`);
+	const onOverflow = opts.onOverflow ?? ((params) => /* @__PURE__ */ new Error(`SSE stream exceeds ${params.maxBytes} bytes (received ${params.size})`));
+	let total = 0;
+	let overflowedFlag = false;
+	let cancelledFlag = false;
+	return {
+		read: async () => {
+			if (overflowedFlag || cancelledFlag) return {
+				done: true,
+				value: void 0
+			};
+			const result = await reader.read();
+			if (result.done) return result;
+			const chunkLen = result.value?.byteLength ?? 0;
+			const next = total + chunkLen;
+			if (next > opts.maxBytes) {
+				overflowedFlag = true;
+				cancelledFlag = true;
+				const err = onOverflow({
+					size: next,
+					maxBytes: opts.maxBytes
+				});
+				try {
+					await reader.cancel(err);
+				} catch {}
+				throw err;
+			}
+			total = next;
+			return result;
+		},
+		cancel: async (reason) => {
+			if (overflowedFlag) return;
+			cancelledFlag = true;
+			try {
+				await reader.cancel(reason);
+			} catch {}
+		},
+		totalBytes: () => total,
+		overflowed: () => overflowedFlag,
+		cancelled: () => cancelledFlag
+	};
+}
+//#endregion
+export { createSseByteGuard as t };

package/dist/tool-schema-json-projection-BXtBc_mD.mjs

@@ -0,0 +1,74 @@
+//#region packages/ai/src/providers/tool-schema-json-projection.ts
+function isJsonValue(value) {
+	if (value === null) return true;
+	switch (typeof value) {
+		case "boolean":
+		case "number":
+		case "string": return true;
+		case "object":
+			if (Array.isArray(value)) return value.every(isJsonValue);
+			return Object.values(value).every(isJsonValue);
+		default: return false;
+	}
+}
+function isJsonObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function serializeToolInputSchema(value, path) {
+	let text;
+	try {
+		text = JSON.stringify(value);
+	} catch {
+		return {
+			schema: {},
+			violations: [`${path} is not JSON-serializable`]
+		};
+	}
+	if (!text) return {
+		schema: {},
+		violations: [`${path} is not JSON-serializable`]
+	};
+	const parsed = JSON.parse(text);
+	if (!isJsonValue(parsed)) return {
+		schema: {},
+		violations: [`${path} is not a JSON value`]
+	};
+	return {
+		schema: parsed,
+		violations: []
+	};
+}
+const schemaMapKeywords = /* @__PURE__ */ new Set([
+	"$defs",
+	"definitions",
+	"dependencies",
+	"dependentSchemas",
+	"patternProperties",
+	"properties"
+]);
+function findDynamicSchemaKeywordViolations(schema, path) {
+	if (Array.isArray(schema)) return schema.flatMap((entry, index) => findDynamicSchemaKeywordViolations(entry, `${path}[${index}]`));
+	if (!isJsonObject(schema)) return [];
+	const violations = [];
+	for (const key of ["$dynamicRef", "$dynamicAnchor"]) if (key in schema) violations.push(`${path}.${key}`);
+	for (const [key, value] of Object.entries(schema)) {
+		if (!value || typeof value !== "object") continue;
+		if (schemaMapKeywords.has(key) && isJsonObject(value)) for (const [schemaName, childSchema] of Object.entries(value)) violations.push(...findDynamicSchemaKeywordViolations(childSchema, `${path}.${key}.${schemaName}`));
+		else violations.push(...findDynamicSchemaKeywordViolations(value, `${path}.${key}`));
+	}
+	return violations;
+}
+/** Projects one runtime tool input schema to JSON and reports runtime incompatibilities. */
+function projectRuntimeToolInputSchema(schema, path = "parameters") {
+	const projection = serializeToolInputSchema(schema, path);
+	const violations = [...projection.violations];
+	if (!isJsonObject(projection.schema)) violations.push(`${path} must be a JSON object schema`);
+	else if (projection.schema.type !== void 0 && projection.schema.type !== "object") violations.push(`${path}.type must be "object"`);
+	violations.push(...findDynamicSchemaKeywordViolations(projection.schema, path));
+	return {
+		schema: projection.schema,
+		violations
+	};
+}
+//#endregion
+export { projectRuntimeToolInputSchema as t };