@openclaw/ai 2026.8.1-beta.3 → 2026.8.2

package/dist/openai-tool-projection-CHGLt03m.mjs

@@ -1,426 +0,0 @@
-import { n as applyProviderReportedUsageCost, r as calculateCost } from "./sanitize-unicode-BP7HLLZn.mjs";
-import { n as getAiTransportHost } from "./host-DF_yxOsA.mjs";
-import { a as isRecord } from "./record-coerce-DdXsgUd_.mjs";
-import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-mZTCdRPo.mjs";
-import { g as notifyProviderHttpResponse, x as transportAbortError } from "./simple-options-oqsXB6U3.mjs";
-import { t as projectRuntimeToolInputSchema } from "./tool-schema-json-projection-FEr-jOoZ.mjs";
-import { t as headersToRecord } from "./headers-B_e4-1J0.mjs";
-//#region packages/ai/src/transports/openai-transport-shared.ts
-/** Shared options, usage shape, cache identity, ordering, and stream scheduling for OpenAI APIs. */
-const MODEL_STREAM_COOPERATIVE_YIELD_INTERVAL_MS = 12;
-const MODEL_STREAM_COOPERATIVE_YIELD_MAX_EVENTS = 64;
-const GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP = "skip_thought_signature_validator";
-const log = {
-	debug(message, data) {
-		getAiTransportHost().logDebug("openai-transport", () => ({
-			message,
-			data
-		}));
-	},
-	info(message, data) {
-		getAiTransportHost().logInfo("openai-transport", message, data);
-	},
-	warn(message, data) {
-		getAiTransportHost().logWarn("openai-transport", message, data);
-	}
-};
-const EMPTY_OPENAI_COMPLETIONS_REASONING_BATCH = {
-	deltas: [],
-	mirroredThinking: [],
-	hasThinking: false,
-	hasVisibleText: false
-};
-const OPENAI_COMPLETIONS_REASONING_FIELDS = [
-	"reasoning_content",
-	"reasoning",
-	"reasoning_text"
-];
-function appendOpenAICompletionsReasoningDelta(batch, next) {
-	if (next.kind === "thinking") batch.hasThinking = true;
-	else batch.hasVisibleText = true;
-	const previous = batch.deltas[batch.deltas.length - 1];
-	if (!previous || previous.kind !== next.kind) {
-		batch.deltas.push(next);
-		if (next.kind === "thinking") batch.mirroredThinking.push(next.text);
-		return;
-	}
-	if (next.kind === "thinking" && previous.kind === "thinking") {
-		if (previous.signature !== next.signature) {
-			batch.deltas.push(next);
-			batch.mirroredThinking.push(next.text);
-			return;
-		}
-		previous.text += next.text;
-		batch.mirroredThinking[batch.mirroredThinking.length - 1] += next.text;
-		return;
-	}
-	previous.text += next.text;
-}
-function createOpenAICompletionsReasoningBatch() {
-	return {
-		deltas: [],
-		mirroredThinking: [],
-		hasThinking: false,
-		hasVisibleText: false
-	};
-}
-function readOpenAICompletionsReasoningBatch(delta, visibleReasoningDetailTypes) {
-	let batch;
-	const reasoningDetails = delta.reasoning_details;
-	let usedReasoningThinkingDetails = false;
-	if (Array.isArray(reasoningDetails)) for (const item of reasoningDetails) {
-		if (!isRecord(item)) continue;
-		const detail = item;
-		if (typeof detail.text !== "string" || !detail.text) continue;
-		if (detail.type === "reasoning.text") {
-			usedReasoningThinkingDetails = true;
-			batch ??= createOpenAICompletionsReasoningBatch();
-			appendOpenAICompletionsReasoningDelta(batch, {
-				kind: "thinking",
-				signature: "reasoning_details",
-				text: detail.text
-			});
-			continue;
-		}
-		if (typeof detail.type === "string" && visibleReasoningDetailTypes.has(detail.type)) {
-			batch ??= createOpenAICompletionsReasoningBatch();
-			appendOpenAICompletionsReasoningDelta(batch, {
-				kind: "text",
-				text: detail.text,
-				source: "reasoning_detail"
-			});
-		}
-	}
-	if (!usedReasoningThinkingDetails) for (const field of OPENAI_COMPLETIONS_REASONING_FIELDS) {
-		const value = delta[field];
-		if (typeof value === "string" && value.length > 0) {
-			batch ??= createOpenAICompletionsReasoningBatch();
-			appendOpenAICompletionsReasoningDelta(batch, {
-				kind: "thinking",
-				signature: field,
-				text: value
-			});
-			break;
-		}
-	}
-	return batch ?? EMPTY_OPENAI_COMPLETIONS_REASONING_BATCH;
-}
-function parseOpenAICompletionsUsage(rawUsage, model, options) {
-	const cacheRead = rawUsage.prompt_tokens_details?.cached_tokens ?? rawUsage.prompt_cache_hit_tokens ?? 0;
-	const cacheWrite = rawUsage.prompt_tokens_details?.cache_write_tokens || 0;
-	const input = Math.max(0, (rawUsage.prompt_tokens || 0) - cacheRead - cacheWrite);
-	const output = rawUsage.completion_tokens || 0;
-	const reasoningTokens = rawUsage.completion_tokens_details?.reasoning_tokens;
-	const usage = {
-		input,
-		output,
-		cacheRead,
-		cacheWrite,
-		...options?.includeReasoningTokens !== false && typeof reasoningTokens === "number" && Number.isFinite(reasoningTokens) ? { reasoningTokens } : {},
-		totalTokens: input + output + cacheRead + cacheWrite,
-		cost: {
-			input: 0,
-			output: 0,
-			cacheRead: 0,
-			cacheWrite: 0,
-			total: 0
-		}
-	};
-	calculateCost(model, usage);
-	applyProviderReportedUsageCost(usage, rawUsage.cost);
-	return usage;
-}
-function createOpenAIResponseHook(onResponse, response, model) {
-	return onResponse ? () => onResponse({
-		status: response.status,
-		headers: headersToRecord(response.headers)
-	}, model) : void 0;
-}
-function createOpenAIProviderAcceptanceHook(options, response, model) {
-	return () => notifyProviderHttpResponse({
-		options,
-		response,
-		model
-	});
-}
-function throwIfModelStreamAborted(signal) {
-	if (signal?.aborted) throw transportAbortError(signal);
-}
-/** Measure one UTF-8 append without double-counting a surrogate pair split across chunks. */
-function measureUtf8AppendBytes(bufferEndsWithHighSurrogate, chunk) {
-	let bytes = Buffer.byteLength(chunk, "utf8");
-	if (!chunk) return {
-		bytes,
-		endsWithHighSurrogate: bufferEndsWithHighSurrogate
-	};
-	const nextCodeUnit = chunk.charCodeAt(0);
-	if (bufferEndsWithHighSurrogate && nextCodeUnit >= 56320 && nextCodeUnit <= 57343) bytes -= 2;
-	const finalCodeUnit = chunk.charCodeAt(chunk.length - 1);
-	return {
-		bytes,
-		endsWithHighSurrogate: finalCodeUnit >= 55296 && finalCodeUnit <= 56319
-	};
-}
-function createModelStreamCooperativeScheduler(signal) {
-	let lastYieldedAt = Date.now();
-	let eventsSinceYield = 0;
-	return { async afterEvent() {
-		throwIfModelStreamAborted(signal);
-		eventsSinceYield += 1;
-		const now = Date.now();
-		if (eventsSinceYield < MODEL_STREAM_COOPERATIVE_YIELD_MAX_EVENTS && now - lastYieldedAt < MODEL_STREAM_COOPERATIVE_YIELD_INTERVAL_MS) return;
-		eventsSinceYield = 0;
-		lastYieldedAt = now;
-		await new Promise((resolve) => {
-			setTimeout(resolve, 0);
-		});
-		throwIfModelStreamAborted(signal);
-	} };
-}
-function resolvePromptCacheKey(options, cacheRetention) {
-	if (cacheRetention === "none") return;
-	return clampOpenAIPromptCacheKey(options?.promptCacheKey ?? options?.sessionId);
-}
-function isOpenAICompletionsThinkingEnabled(effort) {
-	const normalized = effort.trim().toLowerCase();
-	return normalized !== "off" && normalized !== "none";
-}
-function readOpenAICompletionsContentDeltas(content, topLevelRefusal, mirroredThinking = []) {
-	let deltas = readOpenAICompletionsContentPartDeltas(content);
-	if (mirroredThinking.length > 0) {
-		const structuredThinking = deltas.filter((delta) => delta.kind === "thinking").map((delta) => delta.text);
-		const mirrorsCombinedThinking = structuredThinking.length > 1 && mirroredThinking.includes(structuredThinking.join(""));
-		deltas = deltas.filter((delta) => delta.kind !== "thinking" || !mirrorsCombinedThinking && !mirroredThinking.includes(delta.text));
-	}
-	if (typeof topLevelRefusal !== "string" || !topLevelRefusal) return deltas;
-	const structuredRefusals = deltas.filter((delta) => delta.kind === "text" && delta.source === "refusal").map((delta) => delta.text);
-	if (structuredRefusals.some((refusal) => refusal === topLevelRefusal) || structuredRefusals.length > 1 && structuredRefusals.join("") === topLevelRefusal) return deltas;
-	return [...deltas, {
-		kind: "text",
-		text: topLevelRefusal,
-		source: "refusal"
-	}];
-}
-function readOpenAICompletionsContentPartDeltas(content) {
-	if (typeof content === "string") return content ? [{
-		kind: "text",
-		text: content
-	}] : [];
-	if (Array.isArray(content)) return content.flatMap(readOpenAICompletionsContentPartDeltas);
-	if (!content || typeof content !== "object") return [];
-	const record = content;
-	const type = typeof record.type === "string" ? record.type.toLowerCase() : "";
-	const extractText = (value) => {
-		if (typeof value === "string") return value;
-		if (Array.isArray(value)) return value.map(extractText).join("");
-		if (value && typeof value === "object") {
-			const nested = value;
-			return extractText(nested.text ?? nested.content ?? nested.thinking ?? nested.refusal);
-		}
-		return "";
-	};
-	const text = extractText(record.text ?? record.content ?? record.thinking ?? record.refusal);
-	if (!text) return [];
-	if (type.includes("thinking") || type.includes("reasoning")) return [{
-		kind: "thinking",
-		text
-	}];
-	if (type === "refusal") return [{
-		kind: "text",
-		text,
-		source: "refusal"
-	}];
-	if (["text", "output_text"].includes(type) || type.endsWith(".output_text")) return [{
-		kind: "text",
-		text
-	}];
-	return [];
-}
-//#endregion
-//#region packages/ai/src/providers/openai-tool-projection.ts
-function unreadableToolDiagnostic(toolIndex) {
-	return {
-		toolIndex,
-		violations: [`tool[${toolIndex}] is unreadable`]
-	};
-}
-/** Snapshots direct/custom tool descriptors before OpenAI payload construction. */
-function projectOpenAITools(tools) {
-	let inputToolCount;
-	try {
-		inputToolCount = tools.length;
-	} catch {
-		return {
-			inputToolCount: 0,
-			tools: [],
-			diagnostics: [unreadableToolDiagnostic(0)]
-		};
-	}
-	const projectedTools = [];
-	const diagnostics = [];
-	for (let toolIndex = 0; toolIndex < inputToolCount; toolIndex += 1) {
-		let tool;
-		try {
-			const candidate = tools[toolIndex];
-			if (!candidate) {
-				diagnostics.push(unreadableToolDiagnostic(toolIndex));
-				continue;
-			}
-			tool = candidate;
-		} catch {
-			diagnostics.push(unreadableToolDiagnostic(toolIndex));
-			continue;
-		}
-		let name;
-		try {
-			name = tool.name;
-		} catch {
-			diagnostics.push({
-				toolIndex,
-				violations: [`tool[${toolIndex}].name is unreadable`]
-			});
-			continue;
-		}
-		if (typeof name !== "string" || !name) {
-			diagnostics.push({
-				toolIndex,
-				violations: [`tool[${toolIndex}].name is empty`]
-			});
-			continue;
-		}
-		let parameters;
-		try {
-			parameters = tool.parameters;
-		} catch {
-			diagnostics.push({
-				toolIndex,
-				toolName: name,
-				violations: [`${name}.parameters is unreadable`]
-			});
-			continue;
-		}
-		const schemaProjection = projectRuntimeToolInputSchema(parameters ?? {}, `${name}.parameters`);
-		if (!isRecord(schemaProjection.schema) || schemaProjection.violations.length > 0) {
-			diagnostics.push({
-				toolIndex,
-				toolName: name,
-				violations: schemaProjection.violations.length > 0 ? schemaProjection.violations : [`${name}.parameters must be a JSON object schema`]
-			});
-			continue;
-		}
-		let descriptionValue;
-		try {
-			descriptionValue = tool.description;
-		} catch {}
-		const description = typeof descriptionValue === "string" ? descriptionValue : void 0;
-		projectedTools.push({
-			toolIndex,
-			name,
-			...description !== void 0 ? { description } : {},
-			parameters: schemaProjection.schema
-		});
-	}
-	return {
-		inputToolCount,
-		tools: projectedTools,
-		diagnostics
-	};
-}
-function requireProjectedFunction(name, projection, choiceLabel) {
-	if (!projection.tools.some((tool) => tool.name === name)) throw new Error(`${choiceLabel} requested unavailable tool "${name}" after schema conversion`);
-}
-/** Keeps Responses tool choices aligned with surviving function schemas. */
-function reconcileOpenAIResponsesToolChoice(choice, projection) {
-	if (choice === "auto") return projection.tools.length > 0 ? choice : void 0;
-	if (choice === "required") {
-		if (projection.tools.length === 0) throw new Error("OpenAI Responses tool_choice requires a tool, but no tools survived schema conversion");
-		return choice;
-	}
-	if (choice === "none" || !isRecord(choice)) return choice;
-	const choiceType = choice.type;
-	if (choiceType === "function") {
-		const functionName = choice.name;
-		if (typeof functionName !== "string") return choice;
-		requireProjectedFunction(functionName, projection, "OpenAI Responses tool_choice");
-		return {
-			type: "function",
-			name: functionName
-		};
-	}
-	if (choiceType !== "allowed_tools") return choice;
-	const mode = choice.mode;
-	const tools = choice.tools;
-	if (mode !== "auto" && mode !== "required" || !Array.isArray(tools)) return choice;
-	const normalizedAllowedTools = [];
-	for (const tool of tools) {
-		if (!isRecord(tool) || tool.type !== "function") {
-			normalizedAllowedTools.push(tool);
-			continue;
-		}
-		const functionName = tool.name;
-		if (typeof functionName === "string" && projection.tools.some((projectedTool) => projectedTool.name === functionName)) normalizedAllowedTools.push({
-			type: "function",
-			name: functionName
-		});
-	}
-	if (normalizedAllowedTools.length === 0) {
-		if (mode === "auto") return "none";
-		throw new Error("OpenAI Responses tool_choice requires a tool, but no allowed tools survived schema conversion");
-	}
-	return {
-		type: "allowed_tools",
-		mode,
-		tools: normalizedAllowedTools
-	};
-}
-/** Keeps Chat Completions tool choices aligned with surviving function schemas. */
-function reconcileOpenAICompletionsToolChoice(choice, projection) {
-	if (choice === "auto") return projection.tools.length > 0 ? choice : void 0;
-	if (choice === "required") {
-		if (projection.tools.length === 0) throw new Error("OpenAI Chat Completions tool_choice requires a tool, but no tools survived schema conversion");
-		return choice;
-	}
-	if (choice === "none" || !isRecord(choice)) return choice;
-	const choiceType = choice.type;
-	if (choiceType === "custom") throw new Error("OpenAI Chat Completions custom tool_choice is unsupported because this adapter emits function tools only");
-	if (choiceType === "function") {
-		const functionChoice = choice.function;
-		if (!isRecord(functionChoice)) return choice;
-		const functionName = functionChoice.name;
-		if (typeof functionName !== "string") return choice;
-		requireProjectedFunction(functionName, projection, "OpenAI Chat Completions tool_choice");
-		return {
-			type: "function",
-			function: { name: functionName }
-		};
-	}
-	if (choiceType !== "allowed_tools") return choice;
-	const allowedConfig = choice.allowed_tools;
-	if (!isRecord(allowedConfig)) return choice;
-	const mode = allowedConfig.mode;
-	const tools = allowedConfig.tools;
-	if (mode !== "auto" && mode !== "required" || !Array.isArray(tools)) return choice;
-	const normalizedAllowedTools = [];
-	for (const tool of tools) {
-		if (!isRecord(tool) || tool.type !== "function") continue;
-		const functionChoice = tool.function;
-		const functionName = isRecord(functionChoice) ? functionChoice.name : void 0;
-		if (typeof functionName === "string" && projection.tools.some((projectedTool) => projectedTool.name === functionName)) normalizedAllowedTools.push({
-			type: "function",
-			function: { name: functionName }
-		});
-	}
-	if (normalizedAllowedTools.length === 0) {
-		if (mode === "auto") return "none";
-		throw new Error("OpenAI Chat Completions tool_choice requires a tool, but no allowed tools survived schema conversion");
-	}
-	return {
-		type: "allowed_tools",
-		allowed_tools: {
-			mode,
-			tools: normalizedAllowedTools
-		}
-	};
-}
-//#endregion
-export { createModelStreamCooperativeScheduler as a, isOpenAICompletionsThinkingEnabled as c, parseOpenAICompletionsUsage as d, readOpenAICompletionsContentDeltas as f, throwIfModelStreamAborted as h, GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP as i, log as l, resolvePromptCacheKey as m, reconcileOpenAICompletionsToolChoice as n, createOpenAIProviderAcceptanceHook as o, readOpenAICompletionsReasoningBatch as p, reconcileOpenAIResponsesToolChoice as r, createOpenAIResponseHook as s, projectOpenAITools as t, measureUtf8AppendBytes as u };

package/dist/provider-options-AvldWZt8.mjs

@@ -1,21 +0,0 @@
-//#region packages/ai/src/provider-options.ts
-const CODE_MODE_TOOL_SURFACE_OBSERVER = Symbol("openaiCodeModeToolSurfaceObserver");
-const CODE_MODE_TOOL_SURFACE_COLLECTOR = Symbol("openaiCodeModeToolSurfaceCollector");
-const codeModeToolSurfaceObserver = {
-	set(options, observer, collector) {
-		Reflect.set(options, CODE_MODE_TOOL_SURFACE_OBSERVER, observer);
-		if (collector) Reflect.set(options, CODE_MODE_TOOL_SURFACE_COLLECTOR, collector);
-	},
-	get(options) {
-		if (!options) return;
-		const observer = Reflect.get(options, CODE_MODE_TOOL_SURFACE_OBSERVER);
-		return typeof observer === "function" ? (observation) => observer(observation) : void 0;
-	},
-	getCollector(options) {
-		if (!options) return;
-		const collector = Reflect.get(options, CODE_MODE_TOOL_SURFACE_COLLECTOR);
-		return typeof collector === "function" ? (observation) => collector(observation) : void 0;
-	}
-};
-//#endregion
-export { codeModeToolSurfaceObserver as t };

package/dist/record-coerce-DdXsgUd_.mjs

@@ -1,23 +0,0 @@
-//#region packages/normalization-core/src/record-coerce.ts
-/** Type guard for non-array object records at browser-safe boundaries. */
-function isRecord(value) {
-	return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-/** Returns a non-array record or undefined. */
-function asOptionalRecord(value) {
-	return isRecord(value) ? value : void 0;
-}
-/** Returns a non-array record or a fresh ordinary empty record. */
-function asNonArrayRecord(value) {
-	return asOptionalRecord(value) ?? {};
-}
-/** Returns a non-array record or null. */
-function asNullableRecord(value) {
-	return isRecord(value) ? value : null;
-}
-/** Returns any object-backed record, including arrays, or undefined. */
-function asOptionalObjectRecord(value) {
-	return value && typeof value === "object" ? value : void 0;
-}
-//#endregion
-export { isRecord as a, asOptionalRecord as i, asNullableRecord as n, asOptionalObjectRecord as r, asNonArrayRecord as t };

package/dist/src-D2H6yKkH.mjs

@@ -1,2 +0,0 @@
-import "./validation-B61OhAio.mjs";
-export {};

package/dist/stream-first-event-timeout-DvDeSucC.d.mts

@@ -1,29 +0,0 @@
-//#region packages/ai/src/utils/stream-first-event-timeout.d.ts
-type StreamStage = "responses" | "completions";
-type FirstStreamEventTimeoutContext = {
-  provider?: string;
-  api?: string;
-  model?: string;
-  timeoutMs: number;
-  stage?: StreamStage;
-  hint?: string;
-  abort?: (reason: Error) => void;
-  onTimeout?: (reason: Error) => void;
-};
-type FirstStreamEventInternalOptions = {
-  firstEventTimeoutMs?: number;
-  abortFirstEventStream?: (reason: Error) => void;
-  onFirstEventTimeout?: (reason: Error) => void;
-};
-type FirstStreamEventAbortController = {
-  signal: AbortSignal;
-  abort: (reason: Error) => void;
-  dispose: () => void;
-};
-declare function getFirstStreamEventTimeoutMs(options: unknown): number | undefined;
-declare function getFirstStreamEventTimeoutHandler(options: unknown): ((reason: Error) => void) | undefined;
-declare function createFirstStreamEventTimeoutError(context: FirstStreamEventTimeoutContext): Error;
-declare function createFirstStreamEventAbortController(parentSignal?: AbortSignal): FirstStreamEventAbortController;
-declare function withFirstStreamEventTimeout<T>(stream: AsyncIterable<T>, context: FirstStreamEventTimeoutContext): AsyncIterable<T>;
-//#endregion
-export { createFirstStreamEventTimeoutError as a, withFirstStreamEventTimeout as c, createFirstStreamEventAbortController as i, FirstStreamEventInternalOptions as n, getFirstStreamEventTimeoutHandler as o, FirstStreamEventTimeoutContext as r, getFirstStreamEventTimeoutMs as s, FirstStreamEventAbortController as t };

package/dist/string-coerce-fsri9iCu.mjs

@@ -1,34 +0,0 @@
-//#region packages/normalization-core/src/string-coerce.ts
-/** Reads a value only when it is already a string, preserving whitespace. */
-function readStringValue(value) {
-	return typeof value === "string" ? value : void 0;
-}
-/** Trims string input and returns null for non-strings or empty strings. */
-function normalizeNullableString(value) {
-	if (typeof value !== "string") return null;
-	const trimmed = value.trim();
-	return trimmed ? trimmed : null;
-}
-/** Trims string input and returns undefined for non-strings or empty strings. */
-function normalizeOptionalString(value) {
-	return normalizeNullableString(value) ?? void 0;
-}
-/** Stringifies primitive ids/flags before applying optional string normalization. */
-function normalizeStringifiedOptionalString(value) {
-	if (typeof value === "string") return normalizeOptionalString(value);
-	if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return normalizeOptionalString(String(value));
-}
-/** Lowercases a normalized optional string. */
-function normalizeOptionalLowercaseString(value) {
-	return normalizeOptionalString(value)?.toLowerCase();
-}
-/** Lowercases a normalized string or returns an empty string when absent. */
-function normalizeLowercaseStringOrEmpty(value) {
-	return normalizeOptionalLowercaseString(value) ?? "";
-}
-/** Type guard for strings that remain non-empty after trimming. */
-function hasNonEmptyString(value) {
-	return normalizeOptionalString(value) !== void 0;
-}
-//#endregion
-export { normalizeOptionalString as a, normalizeOptionalLowercaseString as i, normalizeLowercaseStringOrEmpty as n, normalizeStringifiedOptionalString as o, normalizeNullableString as r, readStringValue as s, hasNonEmptyString as t };

package/dist/types-BVVgDSdq.d.mts

@@ -1 +0,0 @@
-export { };

package/dist/utf16-slice-CvGodqok.mjs

@@ -1,29 +0,0 @@
-//#region packages/normalization-core/src/utf16-slice.ts
-function isHighSurrogate(codeUnit) {
-	return codeUnit >= 55296 && codeUnit <= 56319;
-}
-function isLowSurrogate(codeUnit) {
-	return codeUnit >= 56320 && codeUnit <= 57343;
-}
-/** Slices a UTF-16 string without returning dangling surrogate halves at either edge. */
-function sliceUtf16Safe(input, start, end) {
-	const len = input.length;
-	let from = start < 0 ? Math.max(len + start, 0) : Math.min(start, len);
-	let to = end === void 0 ? len : end < 0 ? Math.max(len + end, 0) : Math.min(end, len);
-	if (to <= from) return "";
-	if (from > 0 && from < len) {
-		if (isLowSurrogate(input.charCodeAt(from)) && isHighSurrogate(input.charCodeAt(from - 1))) from += 1;
-	}
-	if (to > 0 && to < len) {
-		if (isHighSurrogate(input.charCodeAt(to - 1)) && isLowSurrogate(input.charCodeAt(to))) to -= 1;
-	}
-	return input.slice(from, to);
-}
-/** Truncates a UTF-16 string without cutting a surrogate pair in half. */
-function truncateUtf16Safe(input, maxLen) {
-	const limit = Math.max(0, Math.floor(maxLen));
-	if (input.length <= limit) return input;
-	return sliceUtf16Safe(input, 0, limit);
-}
-//#endregion
-export { truncateUtf16Safe as t };