evalution 1.0.1

package/dist/vercel-ai-sdk-CareWPDM.js

@@ -0,0 +1,759 @@
+import path from "node:path";
+import { SpanStatusCode, trace } from "@opentelemetry/api";
+import fs from "node:fs";
+import { generateText, streamText } from "ai";
+import { extractPropertiesFromDeclaration, findTypeDeclaration } from "ts-proppy";
+import ts from "typescript";
+//#region src/shared/helpers.ts
+function otelOperationToSpanKind(operationName) {
+	switch (operationName) {
+		case "chat":
+		case "response":
+		case "text_completion":
+		case "generate_content": return "LLM";
+		case "execute_tool": return "TOOL";
+		case "create_agent":
+		case "invoke_agent": return "AGENT";
+		case "embeddings": return "EMBEDDING";
+		default: return "DEFAULT";
+	}
+}
+/** Whether a property value can be edited in the UI. */
+function isEditable(value) {
+	return value.kind !== "raw" && !(value.kind === "functionCall" && !value.binding);
+}
+//#endregion
+//#region src/trace/prompt-tracer.ts
+/**
+* Attribute name a span can set to pick one of evalution's span-kind values
+* (`'LLM'`, `'TOOL'`, `'AGENT'`, `'EMBEDDING'`, `'DEFAULT'`). Falls back to
+* `'DEFAULT'` when absent or unrecognised.
+*/
+const SPAN_KIND_ATTRIBUTE = "evalution.span.type";
+/**
+* Attribute name a span can set to scope its {@link PROMPT_ID_ATTRIBUTE} to a
+* specific prompt provider. When absent, the prompt ID is treated as global.
+*/
+const PROMPT_PROVIDER_ID_ATTRIBUTE = "evalution.prompt.provider.id";
+/**
+* Attribute name a span can set to link itself to a specific prompt. The value
+* is a globally-unique prompt ID unless {@link PROMPT_PROVIDER_ID_ATTRIBUTE} is
+* also set, in which case it is scoped to that provider.
+*/
+const PROMPT_ID_ATTRIBUTE = "evalution.prompt.id";
+/**
+* Attribute name a span can set to give a human-readable name to the prompt.
+*/
+const PROMPT_NAME_ATTRIBUTE = "gen_ai.prompt.name";
+/**
+* Wraps a {@link Tracer} so that every span it produces is tagged with the
+* attributes that associate it with a prompt — the prompt's name
+* ({@link PROMPT_NAME_ATTRIBUTE}), an optional global prompt ID
+* ({@link PROMPT_ID_ATTRIBUTE}), and an `'LLM'` span kind
+* ({@link SPAN_KIND_ATTRIBUTE}). Attributes set explicitly on an individual
+* span take precedence over these defaults.
+*
+* This depends only on `@opentelemetry/api`, so it can be re-used by SDK
+* adapter packages (e.g. `@evalution/vercel-ai-sdk`) without pulling in the
+* rest of evalution.
+*
+* @param prompt - The prompt to attribute spans to. `name` is a human-readable
+*   name; the optional `id` is a globally-unique prompt ID used to resolve
+*   runtime traces back to the prompt.
+* @param tracer - Tracer to wrap. Defaults to a tracer from the globally
+*   registered tracer provider.
+* @returns A tracer that forwards to `tracer` while attaching the prompt
+*   attributes to each span it creates.
+*/
+function createTracerForPrompt(prompt, tracer) {
+	const inner = tracer ?? trace.getTracer("evalution");
+	const withPromptAttributes = (options) => ({
+		...options,
+		attributes: {
+			[SPAN_KIND_ATTRIBUTE]: "LLM",
+			[PROMPT_NAME_ATTRIBUTE]: prompt.name,
+			...prompt.id !== void 0 && { ["evalution.prompt.id"]: prompt.id },
+			...options?.attributes
+		}
+	});
+	return {
+		startSpan(name, options, context) {
+			return inner.startSpan(name, withPromptAttributes(options), context);
+		},
+		startActiveSpan(name, ...rest) {
+			if (typeof rest[0] === "function") return inner.startActiveSpan(name, withPromptAttributes(), rest[0]);
+			if (typeof rest[1] === "function") return inner.startActiveSpan(name, withPromptAttributes(rest[0]), rest[1]);
+			return inner.startActiveSpan(name, withPromptAttributes(rest[0]), rest[1], rest[2]);
+		}
+	};
+}
+//#endregion
+//#region src/trace/base-otel-trace-provider.ts
+const KNOWN_KINDS = [
+	"LLM",
+	"TOOL",
+	"AGENT",
+	"EMBEDDING",
+	"DEFAULT"
+];
+function hrTimeToMs(time) {
+	return time[0] * 1e3 + time[1] / 1e6;
+}
+function readKind(attributes) {
+	const raw = attributes["evalution.span.type"] ?? otelOperationToSpanKind(attributes["gen_ai.operation.name"]);
+	return typeof raw === "string" && KNOWN_KINDS.includes(raw) ? raw : "DEFAULT";
+}
+const PARAM_ATTRIBUTES = [
+	"gen_ai.request.temperature",
+	"gen_ai.request.max_tokens",
+	"gen_ai.request.top_k",
+	"gen_ai.request.top_p",
+	"gen_ai.request.frequency_penalty",
+	"gen_ai.request.presence_penalty",
+	"gen_ai.request.seed",
+	"gen_ai.request.stop_sequences",
+	"gen_ai.request.choice.count"
+];
+function str(v) {
+	return typeof v === "string" ? v : void 0;
+}
+function num(v) {
+	return typeof v === "number" ? v : void 0;
+}
+function parseMessages(v) {
+	if (typeof v !== "string") return void 0;
+	try {
+		const parsed = JSON.parse(v);
+		if (!Array.isArray(parsed)) return void 0;
+		return parsed.flatMap((msg) => {
+			if (!msg || typeof msg !== "object") return [];
+			const m = msg;
+			const role = str(m.role) ?? "unknown";
+			const content = m.content;
+			if (typeof content === "string") return [{
+				role,
+				content
+			}];
+			if (Array.isArray(content)) {
+				const text = content.filter((c) => !!c && typeof c === "object").filter((c) => c.type === "text").map((c) => str(c.text) ?? "").join("");
+				return text ? [{
+					role,
+					content: text
+				}] : [];
+			}
+			return [];
+		});
+	} catch {
+		return;
+	}
+}
+function parseOutput(v) {
+	if (typeof v !== "string") return void 0;
+	try {
+		const parsed = JSON.parse(v);
+		if (!Array.isArray(parsed)) return void 0;
+		return parsed.flatMap((msg) => {
+			if (!msg || typeof msg !== "object") return [];
+			const content = msg.content;
+			if (typeof content === "string") return [content];
+			if (Array.isArray(content)) return content.filter((c) => !!c && typeof c === "object").filter((c) => c.type === "text").map((c) => str(c.text) ?? "");
+			return [];
+		}).join("\n");
+	} catch {
+		return;
+	}
+}
+function readLLM(attributes) {
+	const provider = str(attributes["gen_ai.provider.name"]) ?? str(attributes["gen_ai.system"]);
+	const model = str(attributes["gen_ai.response.model"]) ?? str(attributes["gen_ai.request.model"]);
+	const promptTokens = num(attributes["gen_ai.usage.input_tokens"]) ?? num(attributes["ai.usage.promptTokens"]);
+	const completionTokens = num(attributes["gen_ai.usage.output_tokens"]) ?? num(attributes["ai.usage.completionTokens"]);
+	const messages = parseMessages(attributes["gen_ai.input.messages"] ?? attributes["ai.prompt.messages"]);
+	const output = parseOutput(attributes["gen_ai.output.messages"]) ?? str(attributes["ai.response.text"]);
+	const paramEntries = PARAM_ATTRIBUTES.map((key) => [key.replace("gen_ai.request.", ""), attributes[key]]).filter(([, v]) => v !== void 0);
+	const parameters = paramEntries.length > 0 ? Object.fromEntries(paramEntries) : void 0;
+	const totalTokens = promptTokens !== void 0 && completionTokens !== void 0 ? promptTokens + completionTokens : void 0;
+	if (!provider && !model && !promptTokens && !completionTokens && !messages && !output && !parameters) return;
+	return {
+		...provider && { provider },
+		...model && { model },
+		...messages && { messages },
+		...output && { output },
+		...promptTokens !== void 0 && { promptTokens },
+		...completionTokens !== void 0 && { completionTokens },
+		...totalTokens !== void 0 && { totalTokens },
+		...parameters && { parameters }
+	};
+}
+function llmAndPrompt(attributes) {
+	const llm = readLLM(attributes);
+	const id = str(attributes["evalution.prompt.id"]);
+	const providerId = str(attributes["evalution.prompt.provider.id"]);
+	const prompt = id ? {
+		id,
+		...providerId && { providerId }
+	} : void 0;
+	return {
+		...llm && { llm },
+		...prompt && { prompt }
+	};
+}
+function mapStatus(status) {
+	if (status.code === SpanStatusCode.ERROR) return "error";
+	if (status.code === SpanStatusCode.OK) return "ok";
+}
+/**
+* Merges a later snapshot of a span into an earlier one.
+*
+* OpenTelemetry reports each span twice — at `onStart` (creation-time
+* attributes only) and at `onEnd` (the full set) — and the two snapshots can
+* carry complementary data. This unions their `attributes` and lets any
+* *defined* field on `incoming` update `existing`, so nothing recorded at start
+* is lost when the span ends, and end-only fields (status, timings, token
+* usage, …) are filled in.
+*/
+function mergeSpans(existing, incoming) {
+	const merged = { ...existing };
+	for (const [key, value] of Object.entries(incoming)) if (value !== void 0) merged[key] = value;
+	const result = merged;
+	if (existing.attributes || incoming.attributes) result.attributes = {
+		...existing.attributes,
+		...incoming.attributes
+	};
+	return result;
+}
+/**
+* Base class for a {@link TraceProvider} populated by OpenTelemetry spans.
+*
+* Register the processor returned by {@link getSpanProcessor} on a
+* `BasicTracerProvider` (from `@opentelemetry/sdk-trace-base`).
+*/
+var BaseOTelTraceProvider = class {
+	id;
+	displayName;
+	description;
+	subscribers = /* @__PURE__ */ new Map();
+	watchers = /* @__PURE__ */ new Set();
+	spanPromises = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.id = options.id;
+		this.displayName = options.displayName;
+		this.description = options.description;
+	}
+	async getTrace(traceId) {
+		const trace = await this.getTraceWithoutSpans(traceId);
+		if (!trace) return void 0;
+		return {
+			trace,
+			spans: await this.getTraceSpans(traceId)
+		};
+	}
+	subscribeTrace(traceId, callback) {
+		let set = this.subscribers.get(traceId);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			this.subscribers.set(traceId, set);
+		}
+		set.add(callback);
+		return () => {
+			set.delete(callback);
+			if (set.size === 0) this.subscribers.delete(traceId);
+		};
+	}
+	watch(callback) {
+		this.watchers.add(callback);
+		return () => {
+			this.watchers.delete(callback);
+		};
+	}
+	/**
+	* Returns a `SpanProcessor` that funnels every OpenTelemetry span the
+	* caller's tracer produces into this provider's in-memory store.
+	*/
+	getSpanProcessor() {
+		return {
+			onStart: (span, _parentContext) => {
+				const spanId = span.spanContext().spanId;
+				const p = this.handleStart(span).catch(console.error);
+				this.spanPromises.set(spanId, p);
+				p.finally(() => this.spanPromises.delete(spanId));
+			},
+			onEnd: (span) => {
+				const spanId = span.spanContext().spanId;
+				const p = (this.spanPromises.get(spanId) ?? Promise.resolve()).then(() => this.handleEnd(span)).catch(console.error);
+				this.spanPromises.set(spanId, p);
+				p.finally(() => this.spanPromises.delete(spanId));
+			},
+			forceFlush: async () => {},
+			shutdown: async () => {}
+		};
+	}
+	async handleStart(span) {
+		const ctx = span.spanContext();
+		const traceId = ctx.traceId;
+		const spanId = ctx.spanId;
+		const parentCtx = span.parentSpanContext;
+		if ((!parentCtx || parentCtx.traceId !== traceId) && !await this.hasTrace(traceId)) {
+			const startTime = hrTimeToMs(span.startTime);
+			const trace = {
+				id: traceId,
+				providerId: this.id,
+				name: span.name,
+				startTime,
+				status: "running",
+				attributes: { ...span.attributes }
+			};
+			await this.addOrUpdateTrace(trace);
+			this.emitChange({
+				type: "add",
+				traceId
+			});
+		}
+		const ourSpan = {
+			id: spanId,
+			traceId,
+			parentId: parentCtx && parentCtx.traceId === traceId ? parentCtx.spanId : void 0,
+			name: span.name,
+			kind: readKind(span.attributes),
+			startTime: hrTimeToMs(span.startTime),
+			attributes: { ...span.attributes },
+			...llmAndPrompt(span.attributes)
+		};
+		const stored = await this.addOrUpdateSpan(ourSpan);
+		this.emitStream(traceId, {
+			type: "span-start",
+			span: stored
+		});
+	}
+	async handleEnd(span) {
+		const ctx = span.spanContext();
+		const traceId = ctx.traceId;
+		const ended = {
+			id: ctx.spanId,
+			traceId,
+			parentId: span.parentSpanContext && span.parentSpanContext.traceId === traceId ? span.parentSpanContext.spanId : void 0,
+			name: span.name,
+			kind: readKind(span.attributes),
+			startTime: hrTimeToMs(span.startTime),
+			endTime: hrTimeToMs(span.endTime),
+			status: mapStatus(span.status),
+			errorMessage: span.status.code === SpanStatusCode.ERROR ? span.status.message : void 0,
+			attributes: { ...span.attributes },
+			...llmAndPrompt(span.attributes)
+		};
+		const stored = await this.addOrUpdateSpan(ended);
+		this.emitStream(traceId, {
+			type: "span-end",
+			span: stored
+		});
+		if (!stored.parentId) {
+			const existing = await this.getTraceWithoutSpans(traceId);
+			if (existing) {
+				const endedTrace = {
+					...existing,
+					endTime: stored.endTime,
+					status: stored.status === "error" ? "error" : "ok",
+					attributes: {
+						...existing.attributes,
+						...stored.attributes
+					}
+				};
+				await this.addOrUpdateTrace(endedTrace);
+				this.emitStream(traceId, {
+					type: "trace-end",
+					trace: endedTrace
+				});
+				this.emitChange({
+					type: "update",
+					traceId
+				});
+			}
+		}
+	}
+	emitStream(traceId, event) {
+		const set = this.subscribers.get(traceId);
+		if (!set) return;
+		for (const cb of set) try {
+			cb(event);
+		} catch (err) {
+			console.error("Trace subscriber threw:", err);
+		}
+	}
+	emitChange(event) {
+		for (const cb of this.watchers) try {
+			cb(event);
+		} catch (err) {
+			console.error("Trace watcher threw:", err);
+		}
+	}
+	async drainPendingHandlers() {
+		while (this.spanPromises.size > 0) await Promise.all([...this.spanPromises.values()]);
+	}
+};
+//#endregion
+//#region src/trace/memory-trace-provider.ts
+/**
+* In-memory {@link TraceProvider} populated by OpenTelemetry spans.
+*
+* Register the processor returned by {@link getSpanProcessor} on a
+* `BasicTracerProvider` (from `@opentelemetry/sdk-trace-base`).
+*/
+var MemoryTraceProvider = class extends BaseOTelTraceProvider {
+	traces = /* @__PURE__ */ new Map();
+	spansByTrace = /* @__PURE__ */ new Map();
+	constructor({ id = "memory", displayName = "In-Memory Traces", description = "Stores OpenTelemetry spans in memory for the current process." } = {}) {
+		super({
+			id,
+			displayName,
+			description
+		});
+	}
+	async getAllTraces() {
+		const summaries = Array.from(this.traces.values()).map((t) => ({
+			id: t.id,
+			providerId: this.id,
+			name: t.name,
+			startTime: t.startTime,
+			endTime: t.endTime,
+			status: t.status,
+			spanCount: this.spansByTrace.get(t.id)?.length ?? 0
+		}));
+		summaries.sort((a, b) => b.startTime - a.startTime);
+		return summaries;
+	}
+	async hasTrace(traceId) {
+		return this.traces.has(traceId);
+	}
+	async getTraceWithoutSpans(traceId) {
+		return this.traces.get(traceId);
+	}
+	async getTraceSpans(traceId) {
+		return this.spansByTrace.get(traceId) ?? [];
+	}
+	async addOrUpdateTrace(trace) {
+		this.traces.set(trace.id, trace);
+	}
+	async addOrUpdateSpan(span) {
+		let list = this.spansByTrace.get(span.traceId);
+		if (!list) {
+			list = [];
+			this.spansByTrace.set(span.traceId, list);
+		}
+		const idx = list.findIndex((s) => s.id === span.id);
+		if (idx >= 0) {
+			const merged = mergeSpans(list[idx], span);
+			list[idx] = merged;
+			return merged;
+		}
+		list.push(span);
+		return span;
+	}
+};
+//#endregion
+//#region src/shared/setup-task.ts
+/**
+* Shared, dependency-free types describing the onboarding "setup tasks" a user
+* can run to wire up an AI SDK.
+*
+* This module is imported by both the browser client (to render the
+* manual-setup picker) and the server (to define and execute the tasks), so it
+* must stay free of any Node- or DOM-specific imports.
+*/
+/** Path, relative to the project root, where evalution looks for its config. */
+const CONFIG_FILE_RELATIVE_PATH = ".evalution/config.ts";
+/**
+* The shell command a run-style step executes. `install_package` steps map to
+* `npm i <package>`; `run_command` steps carry their command verbatim.
+*/
+function setupStepCommand(step) {
+	return step.kind === "install_package" ? `npm i ${step.package}` : step.command;
+}
+//#endregion
+//#region src/sdk/sdk-adapter.ts
+/**
+* Walk up the directory tree from both `rootDir` and `process.cwd()` looking
+* for `node_modules/<packageName>/<dtsRelPath>`.
+*/
+function findPackageDts(packageName, dtsRelPath, rootDir) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const start of [rootDir, process.cwd()]) {
+		let dir = start;
+		while (!seen.has(dir)) {
+			seen.add(dir);
+			const candidate = path.join(dir, "node_modules", packageName, dtsRelPath);
+			try {
+				fs.accessSync(candidate);
+				return candidate;
+			} catch {}
+			const parent = path.dirname(dir);
+			if (parent === dir) break;
+			dir = parent;
+		}
+	}
+	return null;
+}
+//#endregion
+//#region src/sdk/vercel-ai-sdk.ts
+const MODEL_KEY = "model";
+const SYSTEM_KEY = "system";
+const MESSAGES_KEY = "messages";
+const RESERVED_KEYS = new Set([
+	MODEL_KEY,
+	SYSTEM_KEY,
+	MESSAGES_KEY
+]);
+/** The `prompts()` factory from `@evalution/vercel-ai-sdk`. */
+const PROMPTS_HELPER_CALL = {
+	callee: "prompts",
+	import: {
+		name: "prompts",
+		from: "@evalution/vercel-ai-sdk"
+	}
+};
+/** Build the binding-candidate array for a provider function call. */
+function providerBinding(provider) {
+	return [{
+		kind: "parameter",
+		enclosingCall: PROMPTS_HELPER_CALL
+	}, {
+		kind: "import",
+		spec: {
+			name: provider,
+			from: `@ai-sdk/${provider}`
+		}
+	}];
+}
+/** Build a {@link ModelInfo} entry from group, label, provider, and model ID. */
+function model(group, label, provider, modelId) {
+	const id = `${provider}/${modelId}`;
+	return {
+		id,
+		label,
+		group,
+		values: {
+			function: {
+				kind: "functionCall",
+				callee: provider,
+				args: [{
+					kind: "primitive",
+					value: modelId
+				}],
+				binding: providerBinding(provider)
+			},
+			string: {
+				kind: "primitive",
+				value: id
+			}
+		}
+	};
+}
+/** Build a custom-value template entry for a provider (used in `groups.{provider}.customValueTemplates.function`). */
+function customValueTemplate(provider) {
+	return {
+		kind: "functionCall",
+		callee: provider,
+		args: [{
+			kind: "primitive",
+			value: "$input"
+		}],
+		binding: providerBinding(provider)
+	};
+}
+/** Starter contents of `.evalution/config.ts` for the Vercel AI SDK. */
+const CONFIG_FILE_CONTENTS = `import type { EvalutionConfig } from 'evalution';
+import { FilePromptProvider, VercelAISDK } from 'evalution';
+
+export default {
+  promptProviders: [
+    new FilePromptProvider({
+      sdk: new VercelAISDK(),
+    }),
+  ],
+} satisfies EvalutionConfig;
+`;
+/**
+* {@link SDKAdapter} implementation for the
+* [Vercel AI SDK](https://sdk.vercel.ai/).
+*
+* - `getModelParameters` reads `CallSettings` from the SDK's `.d.ts` bundle
+*   and surfaces parameters with simple types that can be edited in the UI.
+* - `executeConfig` delegates to `generateText`.
+*/
+var VercelAISDK = class {
+	promptsHelperImport = PROMPTS_HELPER_CALL.import.from;
+	/** Onboarding task: install the SDK package, then drop a starter config. */
+	static setupTask = {
+		id: "vercel-ai-sdk",
+		label: "AI SDK",
+		icon: "vercel",
+		steps: [
+			{
+				kind: "install_package",
+				id: "install-ai",
+				package: "ai"
+			},
+			{
+				kind: "install_package",
+				id: "install-evalution-vercel-ai-sdk",
+				package: "@evalution/vercel-ai-sdk"
+			},
+			{
+				kind: "create_config",
+				id: "create-config",
+				path: CONFIG_FILE_RELATIVE_PATH,
+				contents: CONFIG_FILE_CONTENTS
+			}
+		]
+	};
+	getModelCatalog() {
+		return Promise.resolve({
+			modelValueTypes: {
+				function: {
+					label: "Provider",
+					description: "Call provider function (e.g. openai(\"gpt-4o\"))"
+				},
+				string: {
+					label: "Gateway",
+					description: "Use a gateway model string (e.g. \"openai/gpt-4o\")"
+				}
+			},
+			groups: {
+				OpenAI: { customValueTemplates: { function: customValueTemplate("openai") } },
+				Anthropic: { customValueTemplates: { function: customValueTemplate("anthropic") } },
+				Google: { customValueTemplates: { function: customValueTemplate("google") } }
+			},
+			models: [
+				model("OpenAI", "GPT-5.5 Pro", "openai", "gpt-5.5-pro"),
+				model("OpenAI", "GPT-5.5", "openai", "gpt-5.5"),
+				model("OpenAI", "GPT-5.4 Pro", "openai", "gpt-5.4-pro"),
+				model("OpenAI", "GPT-5.4", "openai", "gpt-5.4"),
+				model("OpenAI", "GPT-5.4 mini", "openai", "gpt-5.4-mini"),
+				model("OpenAI", "GPT-5.4 nano", "openai", "gpt-5.4-nano"),
+				model("Anthropic", "Claude Opus 4.8", "anthropic", "claude-opus-4-8"),
+				model("Anthropic", "Claude Sonnet 4.6", "anthropic", "claude-sonnet-4-6"),
+				model("Anthropic", "Claude Haiku 4.5", "anthropic", "claude-haiku-4-5"),
+				model("Google", "Gemini 3.5 Flash", "google", "gemini-3.5-flash"),
+				model("Google", "Gemini 3.1 Pro Preview", "google", "gemini-3.1-pro-preview"),
+				model("Google", "Gemini 3.1 Flash-Lite", "google", "gemini-3.1-flash-lite")
+			]
+		});
+	}
+	getModelParameters(rootDir) {
+		const dtsPath = findPackageDts("ai", "dist/index.d.ts", rootDir);
+		if (!dtsPath) return [];
+		const sourceText = fs.readFileSync(dtsPath, "utf-8");
+		const sourceFile = ts.createSourceFile(dtsPath, sourceText, ts.ScriptTarget.Latest, true);
+		const decl = findTypeDeclaration(sourceFile, "CallSettings");
+		if (!decl) return [];
+		return extractPropertiesFromDeclaration(decl, sourceFile).definitions;
+	}
+	async executeConfig(config, stream) {
+		if (stream) return (await streamText(config)).textStream;
+		else {
+			const result = await generateText(config);
+			return {
+				text: result.text,
+				usage: result.usage,
+				finishReason: result.finishReason
+			};
+		}
+	}
+	normalizePrompt(prompt) {
+		const { definitions, values } = prompt.extractedProps;
+		const modelValue = values?.[MODEL_KEY];
+		const systemValue = values?.[SYSTEM_KEY];
+		const messagesValue = values?.[MESSAGES_KEY];
+		const modelParameters = definitions.filter((d) => !RESERVED_KEYS.has(d.name)).map((def) => {
+			const value = values?.[def.name];
+			return {
+				def,
+				value,
+				editable: value ? isEditable(value) : true
+			};
+		});
+		return {
+			id: prompt.id,
+			providerId: prompt.providerId,
+			globalId: prompt.globalId,
+			name: prompt.name,
+			functionParameters: prompt.functionParameters,
+			metadata: prompt.metadata,
+			treePath: prompt.treePath,
+			model: modelValue,
+			modelEditable: modelValue ? isEditable(modelValue) : true,
+			system: systemValue,
+			systemEditable: systemValue ? isEditable(systemValue) : true,
+			messages: extractMessages(messagesValue),
+			messagesEditable: messagesValue ? isEditable(messagesValue) : true,
+			modelParameters
+		};
+	}
+	denormalizeUpdates(updates, _currentValues) {
+		const out = {};
+		if (MODEL_KEY in updates) out[MODEL_KEY] = updates.model ?? null;
+		if (SYSTEM_KEY in updates) out[SYSTEM_KEY] = updates.system ?? null;
+		if (MESSAGES_KEY in updates) out[MESSAGES_KEY] = updates.messages === null || updates.messages === void 0 ? null : messagesToValue(updates.messages);
+		if (updates.modelParameters) for (const [name, value] of Object.entries(updates.modelParameters)) out[name] = value;
+		return out;
+	}
+};
+function messagesToValue(msgs) {
+	return {
+		kind: "array",
+		elements: msgs.map((msg) => ({
+			kind: "object",
+			properties: {
+				role: {
+					kind: "primitive",
+					value: msg.role
+				},
+				content: msg.content
+			}
+		}))
+	};
+}
+const EMPTY_CONTENT = {
+	kind: "primitive",
+	value: ""
+};
+function extractMessages(value) {
+	if (!value) return [];
+	if (value.kind !== "array") return [{
+		role: "user",
+		content: value
+	}];
+	return value.elements.map((el) => {
+		if (el.kind !== "object") return {
+			role: "user",
+			content: el
+		};
+		const roleValue = el.properties.role;
+		const role = roleValue?.kind === "primitive" ? String(roleValue.value) : "user";
+		const content = el.properties.content ?? EMPTY_CONTENT;
+		const toolCalls = extractToolCalls(el.properties.toolCalls);
+		return toolCalls ? {
+			role,
+			content,
+			toolCalls
+		} : {
+			role,
+			content
+		};
+	});
+}
+function extractToolCalls(value) {
+	if (!value || value.kind !== "array") return void 0;
+	const out = [];
+	for (const el of value.elements) {
+		if (el.kind !== "object") continue;
+		const name = el.properties.toolName;
+		const args = el.properties.args;
+		out.push({
+			toolName: name?.kind === "primitive" ? String(name.value) : "",
+			args: args?.kind === "primitive" ? String(args.value) : ""
+		});
+	}
+	return out.length > 0 ? out : void 0;
+}
+//#endregion
+export { MemoryTraceProvider as a, PROMPT_PROVIDER_ID_ATTRIBUTE as c, isEditable as d, setupStepCommand as i, SPAN_KIND_ATTRIBUTE as l, findPackageDts as n, PROMPT_ID_ATTRIBUTE as o, CONFIG_FILE_RELATIVE_PATH as r, PROMPT_NAME_ATTRIBUTE as s, VercelAISDK as t, createTracerForPrompt as u };