@scuffi/gardener 0.1.1

package/assets/apps/gardener/dist/gardener_runtime/assets/transform-messages-B41ICucH.js

@@ -0,0 +1,246 @@
+//#region ../../node_modules/.pnpm/@earendil-works+pi-ai@0.83.0_@modelcontextprotocol+sdk@1.30.0_@cfworker+json-schema@4.1_c038161535a4cc121d37390bb491fb78/node_modules/@earendil-works/pi-ai/dist/utils/sanitize-unicode.js
+/**
+* Removes unpaired Unicode surrogate characters from a string.
+*
+* Unpaired surrogates (high surrogates 0xD800-0xDBFF without matching low surrogates 0xDC00-0xDFFF,
+* or vice versa) cause JSON serialization errors in many API providers.
+*
+* Valid emoji and other characters outside the Basic Multilingual Plane use properly paired
+* surrogates and will NOT be affected by this function.
+*
+* @param text - The text to sanitize
+* @returns The sanitized text with unpaired surrogates removed
+*
+* @example
+* // Valid emoji (properly paired surrogates) are preserved
+* sanitizeSurrogates("Hello 🙈 World") // => "Hello 🙈 World"
+*
+* // Unpaired high surrogate is removed
+* const unpaired = String.fromCharCode(0xD83D); // high surrogate without low
+* sanitizeSurrogates(`Text ${unpaired} here`) // => "Text  here"
+*/
+function sanitizeSurrogates(text) {
+	return text.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@earendil-works+pi-ai@0.83.0_@modelcontextprotocol+sdk@1.30.0_@cfworker+json-schema@4.1_c038161535a4cc121d37390bb491fb78/node_modules/@earendil-works/pi-ai/dist/api/constrained-sampling.js
+function getGrammarToolInput(toolName, arguments_, inputProperty) {
+	const input = arguments_[inputProperty];
+	if (typeof input !== "string") throw new Error(`Grammar tool call "${toolName}" requires argument "${inputProperty}" to be a string.`);
+	return input;
+}
+function appendGrammarToolInputJsonDelta(buffer, inputProperty, nextInput, close) {
+	if (buffer.closed) {
+		if (close && nextInput === buffer.input) return void 0;
+		throw new Error(`grammar tool input for property "${inputProperty}" changed after it was closed`);
+	}
+	if (!nextInput.startsWith(buffer.input)) throw new Error(`grammar tool input for property "${inputProperty}" changed non-monotonically`);
+	const inputDelta = nextInput.slice(buffer.input.length);
+	if (!close && inputDelta.length === 0) return void 0;
+	let delta = "";
+	if (!buffer.started) {
+		delta += `{${JSON.stringify(inputProperty)}:"`;
+		buffer.started = true;
+	}
+	delta += JSON.stringify(inputDelta).slice(1, -1);
+	buffer.input = nextInput;
+	if (close) {
+		delta += "\"}";
+		buffer.closed = true;
+	}
+	return delta;
+}
+function inferGrammarInputProperty(tool) {
+	const schema = tool.parameters;
+	if (schema.type !== "object") throw new Error("grammar constrained sampling requires an object parameter schema");
+	if (!Array.isArray(schema.required) || schema.required.length !== 1 || typeof schema.required[0] !== "string") throw new Error("grammar constrained sampling requires exactly one required string property");
+	const inputProperty = schema.required[0];
+	if (!schema.properties?.[inputProperty]) throw new Error(`grammar constrained sampling requires a properties entry for ${inputProperty}`);
+	if (schema.properties[inputProperty]?.type !== "string") throw new Error(`grammar constrained sampling property ${inputProperty} must have type string`);
+	return inputProperty;
+}
+function resolveJsonSchemaStrictSampling(tool, supportsStrictMode) {
+	const config = tool.constrainedSampling;
+	if (!config || config.type !== "json_schema") return;
+	if (supportsStrictMode) return true;
+	if (config.strict === "require") throw new Error(`Tool "${tool.name}" requires JSON-schema constrained sampling, but strict tools are unsupported.`);
+}
+function resolveGrammarConstrainedSampling(tool, supportsOpenAIGrammarTools) {
+	const config = tool.constrainedSampling;
+	if (!config || config.type !== "grammar") return;
+	if (!supportsOpenAIGrammarTools) return;
+	const larkDefinition = config.variants.openai_lark;
+	const regexDefinition = config.variants.openai_regex;
+	const hasLarkDefinition = typeof larkDefinition === "string" && larkDefinition.trim().length > 0;
+	const hasRegexDefinition = typeof regexDefinition === "string" && regexDefinition.trim().length > 0;
+	if (!hasLarkDefinition && !hasRegexDefinition) throw new Error(`Tool "${tool.name}" cannot use grammar constrained sampling: no supported grammar variant was provided.`);
+	try {
+		return {
+			format: hasLarkDefinition ? "lark" : "regex",
+			definition: hasLarkDefinition ? larkDefinition : regexDefinition,
+			inputProperty: inferGrammarInputProperty(tool)
+		};
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`Tool "${tool.name}" cannot use grammar constrained sampling: ${message}.`);
+	}
+}
+function createGrammarToolInputProperties(tools, supportsOpenAIGrammarTools) {
+	const properties = /* @__PURE__ */ new Map();
+	for (const tool of tools ?? []) {
+		const grammar = resolveGrammarConstrainedSampling(tool, supportsOpenAIGrammarTools);
+		if (grammar) properties.set(tool.name, grammar.inputProperty);
+	}
+	return properties;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@earendil-works+pi-ai@0.83.0_@modelcontextprotocol+sdk@1.30.0_@cfworker+json-schema@4.1_c038161535a4cc121d37390bb491fb78/node_modules/@earendil-works/pi-ai/dist/api/transform-messages.js
+var NON_VISION_USER_IMAGE_PLACEHOLDER = "(image omitted: model does not support images)";
+var NON_VISION_TOOL_IMAGE_PLACEHOLDER = "(tool image omitted: model does not support images)";
+function replaceImagesWithPlaceholder(content, placeholder) {
+	const result = [];
+	let previousWasPlaceholder = false;
+	for (const block of content) {
+		if (block.type === "image") {
+			if (!previousWasPlaceholder) result.push({
+				type: "text",
+				text: placeholder
+			});
+			previousWasPlaceholder = true;
+			continue;
+		}
+		result.push(block);
+		previousWasPlaceholder = block.text === placeholder;
+	}
+	return result;
+}
+function downgradeUnsupportedImages(messages, model) {
+	if (model.input.includes("image")) return messages;
+	return messages.map((msg) => {
+		if (msg.role === "user" && Array.isArray(msg.content)) return {
+			...msg,
+			content: replaceImagesWithPlaceholder(msg.content, NON_VISION_USER_IMAGE_PLACEHOLDER)
+		};
+		if (msg.role === "toolResult") return {
+			...msg,
+			content: replaceImagesWithPlaceholder(msg.content, NON_VISION_TOOL_IMAGE_PLACEHOLDER)
+		};
+		return msg;
+	});
+}
+/**
+* Normalize tool call ID for cross-provider compatibility.
+* OpenAI Responses API generates IDs that are 450+ chars with special characters like `|`.
+* Anthropic APIs require IDs matching ^[a-zA-Z0-9_-]+$ (max 64 chars).
+*/
+function transformMessages(messages, model, normalizeToolCallId) {
+	const toolCallIdMap = /* @__PURE__ */ new Map();
+	const transformed = downgradeUnsupportedImages(messages.map((msg) => msg.content == null ? {
+		...msg,
+		content: []
+	} : msg), model).map((msg) => {
+		if (msg.role === "user") return msg;
+		if (msg.role === "toolResult") {
+			const normalizedId = toolCallIdMap.get(msg.toolCallId);
+			if (normalizedId && normalizedId !== msg.toolCallId) return {
+				...msg,
+				toolCallId: normalizedId
+			};
+			return msg;
+		}
+		if (msg.role === "assistant") {
+			const assistantMsg = msg;
+			const isSameModel = assistantMsg.provider === model.provider && assistantMsg.api === model.api && assistantMsg.model === model.id;
+			const transformedContent = assistantMsg.content.flatMap((block) => {
+				if (block.type === "thinking") {
+					if (block.redacted) return isSameModel ? block : [];
+					if (isSameModel && block.thinkingSignature) return block;
+					if (!block.thinking || block.thinking.trim() === "") return [];
+					if (isSameModel) return block;
+					return {
+						type: "text",
+						text: block.thinking
+					};
+				}
+				if (block.type === "text") {
+					if (isSameModel) return block;
+					return {
+						type: "text",
+						text: block.text
+					};
+				}
+				if (block.type === "toolCall") {
+					const toolCall = block;
+					let normalizedToolCall = toolCall;
+					if (!isSameModel && toolCall.thoughtSignature) {
+						normalizedToolCall = { ...toolCall };
+						delete normalizedToolCall.thoughtSignature;
+					}
+					if (!isSameModel && normalizeToolCallId) {
+						const normalizedId = normalizeToolCallId(toolCall.id, model, assistantMsg);
+						if (normalizedId !== toolCall.id) {
+							toolCallIdMap.set(toolCall.id, normalizedId);
+							normalizedToolCall = {
+								...normalizedToolCall,
+								id: normalizedId
+							};
+						}
+					}
+					return normalizedToolCall;
+				}
+				return block;
+			});
+			return {
+				...assistantMsg,
+				content: transformedContent
+			};
+		}
+		return msg;
+	});
+	const result = [];
+	let pendingToolCalls = [];
+	let existingToolResultIds = /* @__PURE__ */ new Set();
+	const insertSyntheticToolResults = () => {
+		if (pendingToolCalls.length > 0) {
+			for (const tc of pendingToolCalls) if (!existingToolResultIds.has(tc.id)) result.push({
+				role: "toolResult",
+				toolCallId: tc.id,
+				toolName: tc.name,
+				content: [{
+					type: "text",
+					text: "No result provided"
+				}],
+				isError: true,
+				timestamp: Date.now()
+			});
+			pendingToolCalls = [];
+			existingToolResultIds = /* @__PURE__ */ new Set();
+		}
+	};
+	for (let i = 0; i < transformed.length; i++) {
+		const msg = transformed[i];
+		if (msg.role === "assistant") {
+			insertSyntheticToolResults();
+			const assistantMsg = msg;
+			if (assistantMsg.stopReason === "error" || assistantMsg.stopReason === "aborted") continue;
+			const toolCalls = assistantMsg.content.filter((b) => b.type === "toolCall");
+			if (toolCalls.length > 0) {
+				pendingToolCalls = toolCalls;
+				existingToolResultIds = /* @__PURE__ */ new Set();
+			}
+			result.push(msg);
+		} else if (msg.role === "toolResult") {
+			existingToolResultIds.add(msg.toolCallId);
+			result.push(msg);
+		} else if (msg.role === "user") {
+			insertSyntheticToolResults();
+			result.push(msg);
+		} else result.push(msg);
+	}
+	insertSyntheticToolResults();
+	return result;
+}
+//#endregion
+export { resolveGrammarConstrainedSampling as a, getGrammarToolInput as i, appendGrammarToolInputJsonDelta as n, resolveJsonSchemaStrictSampling as o, createGrammarToolInputProperties as r, sanitizeSurrogates as s, transformMessages as t };
+
+//# sourceMappingURL=transform-messages-B41ICucH.js.map