evalution 1.0.1

package/dist/index.js

@@ -0,0 +1,1325 @@
+import { a as MemoryTraceProvider, c as PROMPT_PROVIDER_ID_ATTRIBUTE, d as isEditable, i as setupStepCommand, l as SPAN_KIND_ATTRIBUTE, n as findPackageDts, o as PROMPT_ID_ATTRIBUTE, s as PROMPT_NAME_ATTRIBUTE, t as VercelAISDK, u as createTracerForPrompt } from "./vercel-ai-sdk-CareWPDM.js";
+import fs, { glob } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import fs$1 from "node:fs";
+import { addProperty, extractPropertiesFromDeclaration, extractPropertiesFromObjectLiteral, extractPropertiesFromParameters, findTypeDeclaration, removeProperty, updateProperty, valueToSourceText } from "ts-proppy";
+import ts from "typescript";
+import chokidar from "chokidar";
+import { makeRe, minimatch } from "minimatch";
+import { GoogleGenAI } from "@google/genai";
+//#region src/file-provider.ts
+/**
+* An in-memory {@link FileProvider} backed by a `Map<string, string>`.
+*
+* Intended for unit tests — all file I/O stays in-process with no disk access.
+* Calling {@link writeFile} triggers any active {@link watch} callbacks
+* synchronously, making it easy to test reactive code paths.
+*
+* @example
+* ```ts
+* const provider = new MemoryFileProvider({
+*   '/virtual/prompt.ts': 'export function myPrompt() { ... }',
+* });
+* const content = await provider.readFile('/virtual/prompt.ts');
+* ```
+*/
+var MemoryFileProvider = class {
+	files;
+	watchers = /* @__PURE__ */ new Set();
+	/**
+	* @param files - Initial file contents keyed by absolute path.
+	*/
+	constructor(files = {}) {
+		this.files = new Map(Object.entries(files));
+	}
+	async readFile(filePath) {
+		const content = this.files.get(filePath);
+		if (content === void 0) throw new Error(`File not found: ${filePath}`);
+		return content;
+	}
+	async writeFile(filePath, content) {
+		const isNew = !this.files.has(filePath);
+		this.files.set(filePath, content);
+		this.notifyWatchers(isNew ? "add" : "change", filePath);
+	}
+	async deleteFile(filePath) {
+		this.files.delete(filePath);
+		this.notifyWatchers("remove", filePath);
+	}
+	async import(filePath) {
+		const content = this.files.get(filePath);
+		if (content === void 0) throw new Error(`File not found: ${filePath}`);
+		return import(`data:text/javascript;charset=utf-8,${encodeURIComponent(content)}`);
+	}
+	async *glob(pattern, options = {}) {
+		const { cwd = process.cwd(), ignore = [], absolute = false } = options;
+		for (const filePath of this.files.keys()) {
+			if (!filePath.startsWith(cwd + path.sep)) continue;
+			const relativePath = path.relative(cwd, filePath).replace(/\\/g, "/");
+			if (!minimatch(relativePath, pattern)) continue;
+			if (ignore.some((p) => minimatch(relativePath, p))) continue;
+			yield absolute ? filePath : relativePath;
+		}
+	}
+	watch(patterns, options, callback) {
+		const watcher = {
+			patterns,
+			cwd: options.cwd ?? process.cwd(),
+			ignored: options.ignored ?? [],
+			callback
+		};
+		this.watchers.add(watcher);
+		return () => {
+			this.watchers.delete(watcher);
+		};
+	}
+	notifyWatchers(eventType, filePath) {
+		for (const watcher of this.watchers) {
+			const { cwd, patterns, ignored, callback } = watcher;
+			if (!filePath.startsWith(cwd + path.sep)) continue;
+			const relativePath = path.relative(cwd, filePath).replace(/\\/g, "/");
+			if (!patterns.some((p) => minimatch(relativePath, p))) continue;
+			if (ignored.some((p) => minimatch(relativePath, p))) continue;
+			callback(eventType, relativePath);
+		}
+	}
+};
+/**
+* A {@link FileProvider} backed by the local file system.
+*
+* Uses `fs/promises` for I/O, `fs/promises.glob` (Node.js ≥ 22) for pattern
+* matching, and [chokidar](https://github.com/paulmillr/chokidar) for file
+* watching.
+*
+* This is the default implementation used by {@link FilePromptProvider} and
+* {@link TSPromptFileType} when no custom provider is supplied.
+*/
+var LocalFileProvider = class {
+	async readFile(filePath) {
+		return fs.readFile(filePath, "utf-8");
+	}
+	async writeFile(filePath, content) {
+		await fs.mkdir(path.dirname(filePath), { recursive: true });
+		await fs.writeFile(filePath, content, "utf-8");
+	}
+	async deleteFile(filePath) {
+		await fs.unlink(filePath);
+	}
+	async import(filePath) {
+		return import(pathToFileURL(filePath).href);
+	}
+	async *glob(pattern, options = {}) {
+		const { cwd, ignore = [], absolute = false } = options;
+		const baseCwd = cwd ?? process.cwd();
+		for await (const file of glob(pattern, { cwd: baseCwd })) {
+			const relativePath = file.replace(/\\/g, "/");
+			if (ignore.some((p) => minimatch(relativePath, p))) continue;
+			yield absolute ? path.resolve(baseCwd, file) : file;
+		}
+	}
+	watch(patterns, options, callback) {
+		const cwd = options.cwd ?? process.cwd();
+		const ignored = options.ignored ?? [];
+		const includeMatchers = patterns.map((p) => makeRe(p)).filter((re) => re !== false);
+		const matches = (fp) => includeMatchers.some((re) => re.test(fp));
+		const watcher = chokidar.watch(".", {
+			cwd,
+			ignored: (absPath) => {
+				const rel = path.relative(cwd, absPath).replace(/\\/g, "/");
+				return ignored.some((p) => minimatch(rel, p, { dot: true }));
+			},
+			persistent: true,
+			ignoreInitial: options.ignoreInitial ?? true
+		});
+		watcher.on("change", (fp) => {
+			if (matches(fp)) callback("change", fp);
+		});
+		watcher.on("add", (fp) => {
+			if (matches(fp)) callback("add", fp);
+		});
+		watcher.on("unlink", (fp) => {
+			if (matches(fp)) callback("remove", fp);
+		});
+		return () => {
+			watcher.close();
+		};
+	}
+};
+//#endregion
+//#region src/prompt/file/ts/ts-prompt-file-type.ts
+/**
+* {@link PromptFileType} implementation for TypeScript `.prompt.ts` files.
+*
+* Each prompt is an exported function that returns an SDK-specific config
+* object. For example, for the Vercel AI SDK, a prompt file might look like this:
+*
+* ```ts
+* import { openai } from '@ai-sdk/openai';
+*
+* export function myPrompt() {
+*   return {
+*     model: openai('gpt-4o'),
+*     system: 'You are a helpful assistant.',
+*     messages: [{ role: 'user', content: 'Hello!' }],
+*   };
+* }
+* ```
+*
+* @example
+* ```ts
+* const fileType = new TSPromptFileType();
+* const prompts = await fileType.parsePrompts(['/path/to/my.prompt.ts'], '/path/to');
+* ```
+*/
+function isValidIdentifier(name) {
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+}
+var TSPromptFileType = class {
+	defaultIncludePatterns = ["**/*.prompt.ts", "**/*.promp.ts"];
+	defaultFileExtension = ".prompt.ts";
+	newPromptSkeleton(promptsId, name, importPath) {
+		const key = isValidIdentifier(name) ? name : `[${JSON.stringify(name)}]`;
+		return `import { prompts } from ${JSON.stringify(importPath)};
+
+export default prompts(
+  ${JSON.stringify(promptsId)},
+  () => ({
+    ${key}: () => ({
+    })
+}));`;
+	}
+	fileProvider;
+	constructor(fileProvider = new LocalFileProvider()) {
+		this.fileProvider = fileProvider;
+	}
+	async parsePrompts(files, rootDir = "") {
+		return (await Promise.all(files.map(async (filePath) => {
+			const sourceCode = await this.fileProvider.readFile(filePath);
+			return this.parseFileContent(filePath, sourceCode, rootDir);
+		}))).flat();
+	}
+	async updateProperty(filePath, propDef, value, promptId) {
+		if (!propDef.valueSpan) throw new Error(`Property '${propDef.name}' is missing valueSpan`);
+		let sourceCode = await this.fileProvider.readFile(filePath);
+		const adjusted = resolveBindingsAndAugment(sourceCode, value);
+		sourceCode = adjusted.sourceCode;
+		const resolvedValue = adjusted.value;
+		const functionName = promptId?.slice(promptId.lastIndexOf("#") + 1);
+		if (functionName) {
+			const freshDef = this.findFreshDefinition(sourceCode, filePath, functionName, propDef.name);
+			if (freshDef) propDef = {
+				...propDef,
+				valueSpan: freshDef.valueSpan,
+				fullSpan: freshDef.fullSpan
+			};
+		}
+		sourceCode = updateProperty(sourceCode, propDef, resolvedValue);
+		await this.fileProvider.writeFile(filePath, sourceCode);
+	}
+	async removeProperty(filePath, propDef) {
+		if (!propDef.fullSpan) throw new Error(`Property '${propDef.name}' is missing fullSpan`);
+		const newSourceCode = removeProperty(await this.fileProvider.readFile(filePath), propDef);
+		await this.fileProvider.writeFile(filePath, newSourceCode);
+	}
+	async addProperty(filePath, promptName, propertyName, value) {
+		let sourceCode = await this.fileProvider.readFile(filePath);
+		const adjusted = resolveBindingsAndAugment(sourceCode, value);
+		sourceCode = adjusted.sourceCode;
+		const resolvedValue = adjusted.value;
+		const sourceFile = ts.createSourceFile(filePath, sourceCode, ts.ScriptTarget.Latest, true);
+		const returnObj = this.findReturnObjectInSource(sourceFile, promptName);
+		if (!returnObj) throw new Error(`Return object not found in function '${promptName}'`);
+		const extracted = extractPropertiesFromObjectLiteral(returnObj, void 0, sourceFile);
+		sourceCode = addProperty(sourceCode, extracted, propertyName, resolvedValue);
+		await this.fileProvider.writeFile(filePath, sourceCode);
+	}
+	async renamePrompt(filePath, oldName, newName) {
+		const sourceCode = await this.fileProvider.readFile(filePath);
+		const sourceFile = ts.createSourceFile(filePath, sourceCode, ts.ScriptTarget.Latest, true);
+		let nameStart = -1;
+		let nameEnd = -1;
+		let isFunctionDeclaration = false;
+		const visit = (node) => {
+			if (nameStart >= 0) return;
+			if (ts.isFunctionDeclaration(node) && node.name?.text === oldName) {
+				nameStart = node.name.getStart(sourceFile);
+				nameEnd = node.name.getEnd();
+				isFunctionDeclaration = true;
+				return;
+			}
+			if (ts.isExportAssignment(node)) {
+				const helper = findPromptsHelperCall(node.expression);
+				if (helper) {
+					for (const prop of helper.object.properties) if (getPropertyName(prop) === oldName) {
+						const nameNode = prop.name;
+						nameStart = nameNode.getStart(sourceFile);
+						nameEnd = nameNode.getEnd();
+						return;
+					}
+				}
+			}
+			ts.forEachChild(node, visit);
+		};
+		visit(sourceFile);
+		if (nameStart < 0) throw new Error(`Function '${oldName}' not found in ${filePath}`);
+		if (!isValidIdentifier(newName) && isFunctionDeclaration) throw new Error(`'${newName}' is not a valid function name`);
+		const replacement = isValidIdentifier(newName) ? newName : `[${JSON.stringify(newName)}]`;
+		const newSource = sourceCode.slice(0, nameStart) + replacement + sourceCode.slice(nameEnd);
+		await this.fileProvider.writeFile(filePath, newSource);
+	}
+	async loadConfig(filePath, promptName, params) {
+		const module = await this.fileProvider.import(filePath);
+		let fn = module[promptName];
+		if (typeof fn !== "function" && typeof module.default === "function") {
+			const obj = module.default();
+			if (obj && typeof obj[promptName] === "function") fn = obj[promptName].bind(obj);
+		}
+		if (typeof fn !== "function") throw new Error(`Function '${promptName}' not found in ${filePath}`);
+		const config = fn(...params);
+		if (!config || typeof config !== "object") throw new Error(`'${promptName}' did not return a valid config object`);
+		return config;
+	}
+	parseFileContent(filePath, sourceCode, rootDir) {
+		const sourceFile = ts.createSourceFile(filePath, sourceCode, ts.ScriptTarget.ESNext, true);
+		const prompts = [];
+		const visitNode = (node) => {
+			if (ts.isFunctionDeclaration(node) && node.name) {
+				if (node.modifiers?.some((mod) => mod.kind === ts.SyntaxKind.ExportKeyword)) {
+					const prompt = this.parseFunctionDeclaration(node, sourceFile, filePath, rootDir);
+					if (prompt) prompts.push(prompt);
+				}
+			} else if (ts.isExportAssignment(node)) {
+				const helper = findPromptsHelperCall(node.expression);
+				if (helper) for (const prop of helper.object.properties) {
+					const parsed = this.parseHelperProperty(prop, sourceFile, filePath, rootDir, helper.moduleId);
+					if (parsed) prompts.push(parsed);
+				}
+			}
+			ts.forEachChild(node, visitNode);
+		};
+		visitNode(sourceFile);
+		return prompts;
+	}
+	parseHelperProperty(prop, sourceFile, filePath, rootDir, moduleId) {
+		const name = getPropertyName(prop);
+		if (!name) return null;
+		const fn = getPropertyFunction(prop);
+		if (!fn) return null;
+		const returnObject = findReturnObjectInFunctionLike(fn);
+		if (!returnObject) return null;
+		const functionParameters = extractPropertiesFromParameters(fn.parameters, sourceFile).definitions;
+		const relativeFilePath = rootDir ? path.relative(rootDir, filePath) : filePath;
+		const extractedProps = extractPropertiesFromObjectLiteral(returnObject, void 0, sourceFile);
+		const treePath = relativeFilePath.split("/").filter(Boolean);
+		return {
+			id: `${relativeFilePath}#${name}`,
+			globalId: moduleId ? `${moduleId}#${name}` : void 0,
+			name,
+			functionParameters,
+			extractedProps,
+			metadata: { relativeFilePath },
+			treePath
+		};
+	}
+	parseFunctionDeclaration(node, sourceFile, filePath, rootDir) {
+		if (!node.name) return null;
+		const functionName = node.name.text;
+		const functionParameters = extractPropertiesFromParameters(node.parameters, sourceFile).definitions;
+		const returnObject = this.findReturnObjectInFunction(node);
+		if (!returnObject) return null;
+		const relativeFilePath = rootDir ? path.relative(rootDir, filePath) : filePath;
+		const promptId = `${relativeFilePath}#${functionName}`;
+		const extractedProps = extractPropertiesFromObjectLiteral(returnObject, void 0, sourceFile);
+		const treePath = relativeFilePath.split("/").filter(Boolean);
+		return {
+			id: promptId,
+			name: functionName,
+			functionParameters,
+			extractedProps,
+			metadata: { relativeFilePath },
+			treePath
+		};
+	}
+	findFreshDefinition(sourceCode, filePath, functionName, propertyName) {
+		const sourceFile = ts.createSourceFile(filePath, sourceCode, ts.ScriptTarget.Latest, true);
+		const returnObj = this.findReturnObjectInSource(sourceFile, functionName);
+		if (!returnObj) return null;
+		return extractPropertiesFromObjectLiteral(returnObj, void 0, sourceFile).definitions.find((d) => d.name === propertyName) ?? null;
+	}
+	findReturnObjectInFunction(node) {
+		let returnObject = null;
+		const visitNode = (n) => {
+			if (ts.isReturnStatement(n) && n.expression) {
+				if (ts.isObjectLiteralExpression(n.expression)) returnObject = n.expression;
+			} else if (ts.isArrowFunction(n) && ts.isObjectLiteralExpression(n.body)) returnObject = n.body;
+			if (!returnObject) ts.forEachChild(n, visitNode);
+		};
+		if (node.body) visitNode(node.body);
+		return returnObject;
+	}
+	findReturnObjectInSource(sourceFile, functionName) {
+		let returnObj = null;
+		const visitFunc = (node) => {
+			if (ts.isFunctionDeclaration(node) && node.name?.text === functionName) {
+				returnObj = this.findReturnObjectInFunction(node);
+				return;
+			}
+			if (ts.isExportAssignment(node)) {
+				const helper = findPromptsHelperCall(node.expression);
+				if (helper) {
+					for (const prop of helper.object.properties) if (getPropertyName(prop) === functionName) {
+						const fn = getPropertyFunction(prop);
+						if (fn) returnObj = findReturnObjectInFunctionLike(fn);
+						return;
+					}
+				}
+			}
+			if (!returnObj) ts.forEachChild(node, visitFunc);
+		};
+		visitFunc(sourceFile);
+		return returnObj;
+	}
+};
+/**
+* If `expr` is a call like `prompts(id, factory)` (or the legacy `prompts(factory)`)
+* whose factory immediately returns an object literal, return that object literal
+* together with the module ID — the first string-literal argument, when present.
+* Otherwise null.
+*/
+function findPromptsHelperCall(expr) {
+	if (!ts.isCallExpression(expr)) return null;
+	if (!ts.isIdentifier(expr.expression) || expr.expression.text !== "prompts") return null;
+	const factory = expr.arguments.find((arg) => ts.isArrowFunction(arg) || ts.isFunctionExpression(arg));
+	if (!factory) return null;
+	const object = findReturnObjectInFunctionLike(factory);
+	if (!object) return null;
+	const first = expr.arguments[0];
+	return {
+		object,
+		moduleId: first && ts.isStringLiteralLike(first) ? first.text : void 0
+	};
+}
+function getPropertyName(prop) {
+	if (ts.isMethodDeclaration(prop) || ts.isPropertyAssignment(prop)) {
+		const name = prop.name;
+		if (ts.isIdentifier(name) || ts.isStringLiteral(name)) return name.text;
+		if (ts.isComputedPropertyName(name) && ts.isStringLiteralLike(name.expression)) return name.expression.text;
+	} else if (ts.isShorthandPropertyAssignment(prop)) return prop.name.text;
+	return null;
+}
+function getPropertyFunction(prop) {
+	if (ts.isMethodDeclaration(prop)) return prop;
+	if (ts.isPropertyAssignment(prop)) {
+		const init = prop.initializer;
+		if (ts.isArrowFunction(init) || ts.isFunctionExpression(init)) return init;
+	}
+	return null;
+}
+/**
+* Resolve binding-array candidates against the file's structure.
+*
+* For each `functionCall` in `value`, walk its `binding` candidates in order
+* and pick the first one that matches the source:
+* - `parameter` candidates match when the file contains the named
+*   `enclosingCall` (e.g. `prompts(({...}) => ...)`) whose first parameter is
+*   a destructured object. The callee is added to that destructure (if not
+*   already present) and the value's `binding` is stripped — the new
+*   functionCall reads its callee from the closure parameter, not a top-level
+*   import.
+* - `import` candidates always match. They collapse the binding to that
+*   single import so ts-proppy's emitter adds the corresponding top-level
+*   import.
+*
+* Returns the (possibly) adjusted source code along with a plain
+* {@link PropValue} ready for ts-proppy.
+*/
+function resolveBindingsAndAugment(sourceCode, value) {
+	const sourceFile = ts.createSourceFile("helper-adjust.ts", sourceCode, ts.ScriptTarget.Latest, true);
+	const destructureAdditions = /* @__PURE__ */ new Map();
+	const resolveCandidate = (_fc, candidates) => {
+		for (const c of candidates) if (c.kind === "parameter") {
+			const dest = findEnclosingCallDestructure(sourceFile, c.enclosingCall);
+			if (dest) return { viaDestructure: dest };
+		} else if (c.kind === "import") return { binding: c };
+		return {};
+	};
+	const adjusted = mapFunctionCalls(value, (fc) => {
+		if (!fc.binding) return fc;
+		const result = resolveCandidate(fc, Array.isArray(fc.binding) ? fc.binding : [fc.binding]);
+		if (result.viaDestructure) {
+			const set = destructureAdditions.get(result.viaDestructure) ?? /* @__PURE__ */ new Set();
+			set.add(fc.callee);
+			destructureAdditions.set(result.viaDestructure, set);
+			const { binding: _drop, ...rest } = fc;
+			return rest;
+		}
+		if (result.binding) return {
+			...fc,
+			binding: result.binding
+		};
+		const { binding: _none, ...rest } = fc;
+		return rest;
+	});
+	const augmentations = [...destructureAdditions.entries()].map(([dest, names]) => {
+		const existing = /* @__PURE__ */ new Set();
+		for (const el of dest.elements) if (ts.isIdentifier(el.name)) existing.add(el.name.text);
+		return {
+			dest,
+			toAdd: [...names].filter((n) => !existing.has(n))
+		};
+	}).filter((a) => a.toAdd.length > 0).sort((a, b) => b.dest.getEnd() - a.dest.getEnd());
+	let nextSource = sourceCode;
+	for (const { dest, toAdd } of augmentations) {
+		let closeOffset = dest.getEnd() - 1;
+		while (nextSource[closeOffset - 1] === " ") closeOffset--;
+		const isEmpty = dest.elements.length === 0;
+		const insertion = (isEmpty ? " " : ", ") + toAdd.join(", ") + (isEmpty ? " " : "");
+		nextSource = nextSource.slice(0, closeOffset) + insertion + nextSource.slice(closeOffset);
+	}
+	return {
+		sourceCode: nextSource,
+		value: adjusted
+	};
+}
+/**
+* Find the destructured first parameter of a call matching `enclosingCall` at
+* the top level of `sourceFile`. Returns null when no such call exists or when
+* its first parameter is not an object binding pattern.
+*
+* When `enclosingCall.import` is provided, the callee identifier must resolve
+* to a named import matching that spec.
+*/
+function findEnclosingCallDestructure(sourceFile, enclosingCall) {
+	if (!enclosingCall) return null;
+	if (!(enclosingCall.import ? sourceFileHasNamedImport(sourceFile, enclosingCall.import.name, enclosingCall.import.from) : true)) return null;
+	let found = null;
+	const visit = (node) => {
+		if (found) return;
+		if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === enclosingCall.callee) {
+			const factory = node.arguments.find((arg) => ts.isArrowFunction(arg) || ts.isFunctionExpression(arg));
+			if (factory) {
+				const param = factory.parameters[0];
+				if (param?.name && ts.isObjectBindingPattern(param.name)) {
+					found = param.name;
+					return;
+				}
+			}
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return found;
+}
+function sourceFileHasNamedImport(sourceFile, name, from) {
+	for (const stmt of sourceFile.statements) {
+		if (!ts.isImportDeclaration(stmt)) continue;
+		if (!ts.isStringLiteral(stmt.moduleSpecifier)) continue;
+		if (stmt.moduleSpecifier.text !== from) continue;
+		const clause = stmt.importClause;
+		if (!clause?.namedBindings || !ts.isNamedImports(clause.namedBindings)) continue;
+		for (const el of clause.namedBindings.elements) if (el.name.text === name) return true;
+	}
+	return false;
+}
+/** Walk a ModelPropValue tree, transforming each functionCall via `fn`. */
+function mapFunctionCalls(value, fn) {
+	switch (value.kind) {
+		case "functionCall": {
+			const mappedArgs = value.args.map((a) => mapFunctionCalls(a, fn));
+			return fn({
+				...value,
+				args: mappedArgs
+			});
+		}
+		case "object": {
+			const properties = {};
+			for (const [k, v] of Object.entries(value.properties)) properties[k] = mapFunctionCalls(v, fn);
+			return {
+				...value,
+				properties
+			};
+		}
+		case "array":
+		case "tuple": return {
+			...value,
+			elements: value.elements.map((el) => mapFunctionCalls(el, fn))
+		};
+		default: return value;
+	}
+}
+function findReturnObjectInFunctionLike(fn) {
+	if (ts.isArrowFunction(fn) && !ts.isBlock(fn.body)) {
+		const body = ts.isParenthesizedExpression(fn.body) ? fn.body.expression : fn.body;
+		return ts.isObjectLiteralExpression(body) ? body : null;
+	}
+	let result = null;
+	const visit = (n) => {
+		if (result) return;
+		if (ts.isReturnStatement(n) && n.expression && ts.isObjectLiteralExpression(n.expression)) {
+			result = n.expression;
+			return;
+		}
+		ts.forEachChild(n, visit);
+	};
+	if (fn.body) visit(fn.body);
+	return result;
+}
+//#endregion
+//#region src/prompt/file/file-prompt-provider.ts
+const DEFAULT_IGNORE_PATTERNS = [
+	"**/node_modules/**",
+	"**/dist/**",
+	"**/.git/**"
+];
+let defaultIDCounter = 0;
+/**
+* A {@link PromptProvider} that discovers and serves prompts from
+* files on the local file system (or any {@link FileProvider}).
+*
+* Out of the box it scans for `**\/*.prompt.ts` files and parses them with
+* {@link TSPromptFileType}. Pass a {@link FilePromptProviderOptions} to the
+* constructor to customize this behavior. You must specify at least
+* {@link FilePromptProviderOptions.sdk}.
+*
+* @example
+* ```ts
+* const provider = new FilePromptProvider({ rootDir: '/my/project', sdk: new VercelAISDK() });
+* const prompts = await provider.getAllPrompts();
+* ```
+*/
+var FilePromptProvider = class {
+	id;
+	displayName = "File System";
+	description = "Create a .prompt.ts file";
+	icon = "<svg width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"currentColor\"><path d=\"M1.5 3A1.5 1.5 0 000 4.5v8A1.5 1.5 0 001.5 14h13a1.5 1.5 0 001.5-1.5v-7A1.5 1.5 0 0014.5 4H8L6.5 2.5h-5z\"/></svg>";
+	files = null;
+	rootDir;
+	fileType;
+	fileProvider;
+	includePatterns;
+	ignorePatterns;
+	sdkAdapter;
+	suppressedWatchEvents = /* @__PURE__ */ new Map();
+	constructor({ id = "fs" + (defaultIDCounter++ ? defaultIDCounter : ""), rootDir = process.cwd(), fileProvider = new LocalFileProvider(), fileType, includePatterns, ignorePatterns = DEFAULT_IGNORE_PATTERNS, sdk }) {
+		fileType ??= new TSPromptFileType(fileProvider);
+		this.id = id;
+		this.rootDir = rootDir;
+		this.fileProvider = fileProvider;
+		this.fileType = fileType;
+		this.includePatterns = includePatterns ?? fileType.defaultIncludePatterns;
+		this.ignorePatterns = ignorePatterns;
+		this.sdkAdapter = sdk;
+	}
+	async getAllPrompts() {
+		await this.ensureFiles();
+		return (await this.fileType.parsePrompts(this.files, this.rootDir)).map((p) => this.normalizeFilePrompt(p));
+	}
+	async getPrompt(id) {
+		const parsed = await this.getParsedPrompt(id);
+		return parsed ? this.normalizeFilePrompt(parsed) : null;
+	}
+	async updatePromptProperties(promptId, updates) {
+		const parsed = await this.getParsedPrompt(promptId);
+		if (!parsed) throw new Error("Prompt not found");
+		const [filePath, promptName] = this.parsePromptId(promptId);
+		const { definitions, values } = parsed.extractedProps;
+		const rawUpdates = this.sdkAdapter.denormalizeUpdates(updates, values);
+		for (const [propertyName, value] of Object.entries(rawUpdates)) {
+			this.suppressNextWatchEvent(filePath, "change");
+			const propDef = definitions.find((d) => d.name === propertyName);
+			const currentValue = values?.[propertyName];
+			if (value === null) {
+				if (!propDef) throw new Error(`Property '${propertyName}' not found`);
+				await this.fileType.removeProperty(filePath, propDef);
+			} else if (!propDef) await this.fileType.addProperty(filePath, promptName, propertyName, value);
+			else {
+				if (currentValue && !isEditable(currentValue)) throw new Error(`Property '${propertyName}' is not editable`);
+				if (!propDef.valueSpan) throw new Error(`Property '${propertyName}' is missing source metadata`);
+				await this.fileType.updateProperty(filePath, propDef, value, promptId);
+			}
+		}
+		return await this.getPrompt(promptId);
+	}
+	async getParsedPrompt(id) {
+		const [filePath, name] = this.parsePromptId(id);
+		let prompts;
+		try {
+			prompts = await this.fileType.parsePrompts([filePath], this.rootDir);
+		} catch {
+			return null;
+		}
+		return prompts.find((p) => p.name === name) || null;
+	}
+	normalizeFilePrompt(parsed) {
+		return {
+			...this.sdkAdapter.normalizePrompt(parsed),
+			metadata: parsed.metadata
+		};
+	}
+	getModelCatalog() {
+		return this.sdkAdapter.getModelCatalog();
+	}
+	getModelParameters() {
+		return this.sdkAdapter.getModelParameters(this.rootDir);
+	}
+	async execute(promptId, params, stream) {
+		const [filePath, promptName] = this.parsePromptId(promptId);
+		const config = await this.fileType.loadConfig(filePath, promptName, params);
+		return this.sdkAdapter.executeConfig(config, stream);
+	}
+	async renamePrompt(promptId, newName) {
+		const [filePath, oldName] = this.parsePromptId(promptId);
+		this.suppressNextWatchEvent(filePath, "change");
+		await this.fileType.renamePrompt(filePath, oldName, newName);
+		const relFilePath = path.relative(this.rootDir, filePath);
+		const prompt = await this.getPrompt(`${relFilePath}#${newName}`);
+		if (!prompt) throw new Error("Failed to find renamed prompt");
+		return prompt;
+	}
+	async addPrompt(partial) {
+		const relFilePath = partial.metadata?.relativeFilePath;
+		if (relFilePath) {
+			const normalizedRelFilePath = path.extname(relFilePath) ? relFilePath : relFilePath + this.fileType.defaultFileExtension;
+			const absPath = path.join(this.rootDir, normalizedRelFilePath);
+			const baseName = path.basename(normalizedRelFilePath);
+			const firstDot = baseName.indexOf(".");
+			const promptsId = firstDot >= 0 ? baseName.slice(0, firstDot) : baseName;
+			const name = partial.name ?? promptsId;
+			const content = this.fileType.newPromptSkeleton(promptsId, name, this.sdkAdapter.promptsHelperImport);
+			this.suppressNextWatchEvent(absPath, "add");
+			await this.fileProvider.writeFile(absPath, content);
+			if (this.files && !this.files.includes(absPath)) this.files.push(absPath);
+			const prompt = await this.getPrompt(`${normalizedRelFilePath}#${name}`);
+			if (!prompt) throw new Error("Failed to create prompt");
+			return prompt;
+		}
+		const directories = await this.listDirectories();
+		const prompts = await this.getAllPrompts();
+		const dirCounts = /* @__PURE__ */ new Map();
+		for (const p of prompts) {
+			const dir = path.dirname(p.metadata.relativeFilePath);
+			dirCounts.set(dir, (dirCounts.get(dir) ?? 0) + 1);
+		}
+		let defaultDir = ".";
+		let maxCount = 0;
+		for (const [dir, count] of dirCounts) if (count > maxCount && directories.includes(dir)) {
+			defaultDir = dir;
+			maxCount = count;
+		}
+		return { fields: [
+			{
+				name: "directory",
+				label: "Directory",
+				type: "select",
+				required: true,
+				defaultValue: defaultDir,
+				options: directories.map((d) => ({
+					label: d === "." ? "(root)" : d,
+					value: d
+				}))
+			},
+			{
+				name: "fileName",
+				label: "File name",
+				type: "text",
+				required: true,
+				placeholder: `my-prompt (or my-prompt${this.fileType.defaultFileExtension})`
+			},
+			{
+				name: "name",
+				label: "Prompt name",
+				type: "text",
+				required: false,
+				placeholder: "Default: file name without extension"
+			}
+		] };
+	}
+	watch(callback) {
+		return this.fileProvider.watch(this.includePatterns, {
+			cwd: this.rootDir,
+			ignored: this.ignorePatterns
+		}, async (eventType, filePath) => {
+			const absolutePath = this.resolveFilePath(filePath);
+			if (this.consumeSuppressedWatchEvent(absolutePath, eventType)) return;
+			if (eventType === "change" || eventType === "add") {
+				if (this.files && !this.files.includes(absolutePath)) this.files.push(absolutePath);
+				(await this.fileType.parsePrompts([absolutePath], this.rootDir)).forEach((prompt) => {
+					callback({
+						type: eventType === "change" ? "change" : "add",
+						promptId: prompt.id
+					});
+				});
+			} else {
+				if (this.files) this.files = this.files.filter((f) => f !== absolutePath);
+				callback({
+					type: "remove",
+					promptId: filePath
+				});
+			}
+		});
+	}
+	async ensureFiles() {
+		if (!this.files) this.files = await Array.fromAsync(this.findPromptFiles());
+	}
+	suppressNextWatchEvent(filePath, eventType) {
+		if (eventType !== "change" && eventType !== "add") return;
+		const key = `${eventType}:${filePath}`;
+		const entry = this.suppressedWatchEvents.get(key);
+		this.suppressedWatchEvents.set(key, {
+			remaining: (entry?.remaining ?? 0) + 1,
+			expiresAt: Date.now() + 2e3
+		});
+	}
+	consumeSuppressedWatchEvent(filePath, eventType) {
+		const key = `${eventType}:${filePath}`;
+		const entry = this.suppressedWatchEvents.get(key);
+		if (!entry) return false;
+		if (entry.expiresAt < Date.now()) {
+			this.suppressedWatchEvents.delete(key);
+			return false;
+		}
+		if (entry.remaining <= 1) this.suppressedWatchEvents.delete(key);
+		else this.suppressedWatchEvents.set(key, {
+			remaining: entry.remaining - 1,
+			expiresAt: entry.expiresAt
+		});
+		return true;
+	}
+	async *findPromptFiles() {
+		const uniqueFiles = /* @__PURE__ */ new Set();
+		for (const pattern of this.includePatterns) {
+			const iter = this.fileProvider.glob(pattern, {
+				cwd: this.rootDir,
+				absolute: true,
+				ignore: this.ignorePatterns
+			});
+			for await (const file of iter) if (!uniqueFiles.has(file)) {
+				uniqueFiles.add(file);
+				yield file;
+			}
+		}
+	}
+	parsePromptId(id) {
+		const hashIdx = id.lastIndexOf("#");
+		if (hashIdx < 0) throw new Error(`Invalid prompt ID format: ${id}`);
+		const relativePath = id.slice(0, hashIdx);
+		const functionName = id.slice(hashIdx + 1);
+		return [path.isAbsolute(relativePath) ? relativePath : path.join(this.rootDir, relativePath), functionName];
+	}
+	async listDirectories() {
+		const dirs = new Set(["."]);
+		const iter = this.fileProvider.glob("**/", {
+			cwd: this.rootDir,
+			ignore: this.ignorePatterns
+		});
+		for await (const dir of iter) {
+			const clean = dir.replace(/\/$/, "");
+			if (clean) dirs.add(clean);
+		}
+		return Array.from(dirs).sort();
+	}
+	resolveFilePath(relativePath) {
+		if (relativePath.startsWith("/")) return relativePath;
+		return `${this.rootDir}/${relativePath}`;
+	}
+};
+//#endregion
+//#region src/sdk/gemini-interactions-sdk.ts
+const MODEL_KEY = "model";
+const AGENT_KEY = "agent";
+const SYSTEM_KEY = "system_instruction";
+const INPUT_KEY = "input";
+const GENERATION_CONFIG_KEY = "generation_config";
+const FALLBACK_GENERATION_CONFIG_PARAMS = [
+	{
+		name: "temperature",
+		description: "Controls the randomness of the output.",
+		type: {
+			kind: "primitive",
+			syntax: "number"
+		},
+		optional: true
+	},
+	{
+		name: "top_p",
+		description: "The maximum cumulative probability of tokens to consider when sampling.",
+		type: {
+			kind: "primitive",
+			syntax: "number"
+		},
+		optional: true
+	},
+	{
+		name: "max_output_tokens",
+		description: "The maximum number of tokens to include in the response.",
+		type: {
+			kind: "primitive",
+			syntax: "number"
+		},
+		optional: true
+	},
+	{
+		name: "seed",
+		description: "Seed used in decoding for reproducibility.",
+		type: {
+			kind: "primitive",
+			syntax: "number"
+		},
+		optional: true
+	},
+	{
+		name: "stop_sequences",
+		description: "A list of character sequences that will stop output interaction.",
+		type: {
+			kind: "array",
+			syntax: "string[]",
+			elementType: {
+				kind: "primitive",
+				syntax: "string"
+			}
+		},
+		optional: true
+	},
+	{
+		name: "thinking_level",
+		description: "The level of thought tokens that the model should generate.",
+		type: {
+			kind: "union",
+			syntax: "'minimal' | 'low' | 'medium' | 'high'",
+			types: [
+				{
+					kind: "constant",
+					syntax: "'minimal'",
+					value: "minimal"
+				},
+				{
+					kind: "constant",
+					syntax: "'low'",
+					value: "low"
+				},
+				{
+					kind: "constant",
+					syntax: "'medium'",
+					value: "medium"
+				},
+				{
+					kind: "constant",
+					syntax: "'high'",
+					value: "high"
+				}
+			]
+		},
+		optional: true
+	},
+	{
+		name: "thinking_summaries",
+		description: "Whether to include thought summaries in the response.",
+		type: {
+			kind: "union",
+			syntax: "'auto' | 'none'",
+			types: [{
+				kind: "constant",
+				syntax: "'auto'",
+				value: "auto"
+			}, {
+				kind: "constant",
+				syntax: "'none'",
+				value: "none"
+			}]
+		},
+		optional: true
+	}
+];
+/**
+* {@link SDKAdapter} implementation for the Google GenAI
+* [Interactions API](https://ai.google.dev/gemini-api/docs/interactions)
+* (`@google/genai` package). Currently experimental and untested.
+*/
+var GeminiInteractionsSDK = class {
+	promptsHelperImport = "FIXME";
+	getModelCatalog() {
+		return Promise.resolve({
+			modelValueTypes: {
+				model: {
+					label: "Models",
+					description: "Models"
+				},
+				agent: {
+					label: "Agents",
+					description: "Agents"
+				}
+			},
+			groups: { Google: { customValueTemplates: {
+				model: {
+					kind: "object",
+					properties: {
+						key: {
+							kind: "primitive",
+							value: "model"
+						},
+						value: {
+							kind: "primitive",
+							value: "$input"
+						}
+					}
+				},
+				agent: {
+					kind: "object",
+					properties: {
+						key: {
+							kind: "primitive",
+							value: "agent"
+						},
+						value: {
+							kind: "primitive",
+							value: "$input"
+						}
+					}
+				}
+			} } },
+			models: [
+				{
+					id: "gemini-3.1-pro-preview",
+					label: "Gemini 3.1 Pro Preview",
+					values: { model: {
+						kind: "object",
+						properties: {
+							key: {
+								kind: "primitive",
+								value: "model"
+							},
+							value: {
+								kind: "primitive",
+								value: "gemini-3.1-pro-preview"
+							}
+						},
+						displayValue: "gemini-3.1-pro-preview"
+					} },
+					group: "Google"
+				},
+				{
+					id: "gemini-3-flash-preview",
+					label: "Gemini 3 Flash Preview",
+					values: { model: {
+						kind: "object",
+						properties: {
+							key: {
+								kind: "primitive",
+								value: "model"
+							},
+							value: {
+								kind: "primitive",
+								value: "gemini-3-flash-preview"
+							}
+						},
+						displayValue: "gemini-3-flash-preview"
+					} },
+					group: "Google"
+				},
+				{
+					id: "gemini-3.1-flash-lite-preview",
+					label: "Gemini 3.1 Flash-Lite Preview",
+					values: { model: {
+						kind: "object",
+						properties: {
+							key: {
+								kind: "primitive",
+								value: "model"
+							},
+							value: {
+								kind: "primitive",
+								value: "gemini-3.1-flash-lite-preview"
+							}
+						},
+						displayValue: "gemini-3.1-flash-lite-preview"
+					} },
+					group: "Google"
+				},
+				{
+					id: "gemini-2.5-pro",
+					label: "Gemini 2.5 Pro",
+					values: { model: {
+						kind: "object",
+						properties: {
+							key: {
+								kind: "primitive",
+								value: "model"
+							},
+							value: {
+								kind: "primitive",
+								value: "gemini-2.5-pro"
+							}
+						},
+						displayValue: "gemini-2.5-pro"
+					} },
+					group: "Google"
+				},
+				{
+					id: "gemini-2.5-flash",
+					label: "Gemini 2.5 Flash",
+					values: { model: {
+						kind: "object",
+						properties: {
+							key: {
+								kind: "primitive",
+								value: "model"
+							},
+							value: {
+								kind: "primitive",
+								value: "gemini-2.5-flash"
+							}
+						},
+						displayValue: "gemini-2.5-flash"
+					} },
+					group: "Google"
+				},
+				{
+					id: "gemini-2.5-flash-lite",
+					label: "Gemini 2.5 Flash-lite",
+					values: { model: {
+						kind: "object",
+						properties: {
+							key: {
+								kind: "primitive",
+								value: "model"
+							},
+							value: {
+								kind: "primitive",
+								value: "gemini-2.5-flash-lite"
+							}
+						},
+						displayValue: "gemini-2.5-flash-lite"
+					} },
+					group: "Google"
+				},
+				{
+					id: "deep-research-pro-preview-12-2025",
+					label: "Deep Research Preview",
+					values: { agent: {
+						kind: "object",
+						properties: {
+							key: {
+								kind: "primitive",
+								value: "agent"
+							},
+							value: {
+								kind: "primitive",
+								value: "deep-research-pro-preview-12-2025"
+							}
+						},
+						displayValue: "deep-research-pro-preview-12-2025"
+					} },
+					group: "Google"
+				}
+			]
+		});
+	}
+	getModelParameters(rootDir) {
+		const dtsPath = findPackageDts("@google/genai", "dist/genai.d.ts", rootDir);
+		if (dtsPath) try {
+			const sourceText = fs$1.readFileSync(dtsPath, "utf-8");
+			const sourceFile = ts.createSourceFile(dtsPath, sourceText, ts.ScriptTarget.Latest, true);
+			const decl = findTypeDeclaration(sourceFile, "GenerationConfig_2");
+			if (decl) return extractPropertiesFromDeclaration(decl, sourceFile).definitions;
+		} catch {}
+		return FALLBACK_GENERATION_CONFIG_PARAMS;
+	}
+	async executeConfig(config, stream) {
+		const result = await new GoogleGenAI({}).interactions.create({
+			...config,
+			stream,
+			store: false
+		});
+		if ("id" in result) return {
+			text: (result.outputs ?? []).find((o) => o.type === "text")?.text ?? "",
+			usage: result.usage
+		};
+		else return streamTextFromSSE(result);
+	}
+	normalizePrompt(prompt) {
+		const { definitions, values } = prompt.extractedProps;
+		const systemValue = values?.[SYSTEM_KEY];
+		const inputValue = values?.[INPUT_KEY];
+		const modelValue = values?.[MODEL_KEY];
+		const agentValue = values?.[AGENT_KEY];
+		let model;
+		let modelEditable = false;
+		if (modelValue) {
+			model = {
+				kind: "object",
+				properties: {
+					key: {
+						kind: "primitive",
+						value: "model"
+					},
+					value: modelValue
+				},
+				displayValue: valueToSourceText(modelValue)
+			};
+			modelEditable = isEditable(modelValue);
+		} else if (agentValue) {
+			model = {
+				kind: "object",
+				properties: {
+					key: {
+						kind: "primitive",
+						value: "agent"
+					},
+					value: agentValue
+				},
+				displayValue: valueToSourceText(agentValue)
+			};
+			modelEditable = isEditable(agentValue);
+		}
+		const genConfigDef = definitions.find((d) => d.name === GENERATION_CONFIG_KEY);
+		const genConfigValue = values?.[GENERATION_CONFIG_KEY];
+		const genConfigProps = genConfigValue?.kind === "object" ? genConfigValue.properties : {};
+		const modelParameters = (genConfigDef?.type.kind === "object" ? genConfigDef.type.properties : []).map((def) => {
+			const value = genConfigProps[def.name];
+			return {
+				def,
+				value,
+				editable: value ? isEditable(value) : true
+			};
+		});
+		return {
+			id: prompt.id,
+			providerId: prompt.providerId,
+			name: prompt.name,
+			functionParameters: prompt.functionParameters,
+			metadata: prompt.metadata,
+			treePath: prompt.treePath,
+			model,
+			modelEditable,
+			system: systemValue,
+			systemEditable: systemValue ? isEditable(systemValue) : true,
+			messages: extractMessages(inputValue),
+			messagesEditable: inputValue ? isEditable(inputValue) : true,
+			modelParameters
+		};
+	}
+	denormalizeUpdates(updates, currentValues) {
+		const out = {};
+		if ("model" in updates) {
+			if (currentValues && MODEL_KEY in currentValues) out[MODEL_KEY] = null;
+			if (currentValues && AGENT_KEY in currentValues) out[AGENT_KEY] = null;
+			const modelUpdate = updates.model;
+			if (modelUpdate?.kind === "object" && modelUpdate.properties.key?.kind === "primitive") {
+				const key = String(modelUpdate.properties.key.value);
+				out[key] = modelUpdate.properties.value;
+			}
+		}
+		if ("system" in updates) out[SYSTEM_KEY] = updates.system ?? null;
+		if ("messages" in updates) out[INPUT_KEY] = updates.messages == null ? null : messagesToValue(updates.messages);
+		if (updates.modelParameters) {
+			const current = currentValues?.[GENERATION_CONFIG_KEY];
+			const merged = current?.kind === "object" ? { ...current.properties } : {};
+			for (const [name, value] of Object.entries(updates.modelParameters)) if (value === null) delete merged[name];
+			else merged[name] = value;
+			out[GENERATION_CONFIG_KEY] = Object.keys(merged).length > 0 ? {
+				kind: "object",
+				properties: merged
+			} : null;
+		}
+		return out;
+	}
+};
+/**
+* Convert a {@link NormalizedMessage} array into a PropValue representing the
+* `input` property: an array of [Step](https://ai.google.dev/api/interactions-api#Resource:Step)
+* objects (`{type: 'user_input' | 'model_output', content: [...]}`), each
+* carrying a single text [Content](https://ai.google.dev/api/interactions-api#schema-example-Content-text).
+*/
+function messagesToValue(msgs) {
+	return {
+		kind: "array",
+		elements: msgs.map((msg) => ({
+			kind: "object",
+			properties: {
+				type: {
+					kind: "primitive",
+					value: msg.role === "assistant" ? "model_output" : "user_input"
+				},
+				content: {
+					kind: "array",
+					elements: [{
+						kind: "object",
+						properties: {
+							type: {
+								kind: "primitive",
+								value: "text"
+							},
+							text: msg.content
+						}
+					}]
+				}
+			}
+		}))
+	};
+}
+const EMPTY_CONTENT = {
+	kind: "primitive",
+	value: ""
+};
+function extractContent(el) {
+	if (el?.kind !== "object" || el.properties.type?.kind !== "primitive") return;
+	switch (el.properties.type.value) {
+		case "text": return {
+			role: "user",
+			content: el.properties.text ?? EMPTY_CONTENT
+		};
+	}
+}
+/**
+* Extract a {@link NormalizedMessage} array from the `input` PropValue.
+*
+* The `input` field can be:
+* - A primitive string (single user message)
+* - A single content object (e.g. `{type: 'text', text: '...'}`)
+* - An array of Step objects (https://ai.google.dev/api/interactions-api#Resource:Step)
+* - An array of Content objects (https://ai.google.dev/api/interactions-api#schema-example-Content-text)
+*
+* The Interactions API uses `"model"` for assistant messages; we translate
+* `"model"` → `"assistant"` on the way in.
+*/
+function extractMessages(value) {
+	if (!value) return [];
+	const content = extractContent(value);
+	if (content) return [content];
+	if (value.kind !== "array") return [{
+		role: "user",
+		content: value
+	}];
+	const results = [];
+	for (const el of value.elements) {
+		const content = extractContent(el);
+		if (content) {
+			results.push(content);
+			continue;
+		}
+		if (el.kind !== "object" || el.properties.type?.kind !== "primitive") continue;
+		switch (el.properties.type.value) {
+			case "user_input":
+				results.push(...extractMessages(el.properties.content));
+				break;
+			case "model_output":
+				for (const msg of extractMessages(el.properties.content)) results.push({
+					...msg,
+					role: "assistant"
+				});
+				break;
+		}
+	}
+	return results;
+}
+/**
+* Yields text chunks from the Interactions API SSE stream.
+*/
+async function* streamTextFromSSE(stream) {
+	for await (const chunk of stream) if (chunk.event_type === "content.delta") {
+		if (chunk.delta?.type === "text" && chunk.delta.text) yield chunk.delta.text;
+	}
+}
+//#endregion
+export { FilePromptProvider, GeminiInteractionsSDK, LocalFileProvider, MemoryFileProvider, MemoryTraceProvider, PROMPT_ID_ATTRIBUTE, PROMPT_NAME_ATTRIBUTE, PROMPT_PROVIDER_ID_ATTRIBUTE, SPAN_KIND_ATTRIBUTE, TSPromptFileType, VercelAISDK, createTracerForPrompt, setupStepCommand };