@inkeep/agents-cli 0.51.0 → 0.53.0

package/dist/agents-cli/package.js

@@ -0,0 +1,6 @@
+//#region package.json
+var name = "@inkeep/agents-cli";
+var version = "0.53.0";
+
+//#endregion
+export { name, version };

package/dist/commands/config.js

@@ -1,8 +1,8 @@
 import { LOCAL_REMOTE } from "../utils/profiles/types.js";
 import "../utils/profiles/index.js";
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import chalk from "chalk";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
 
 //#region src/commands/config.ts
 async function configGetCommand(key, options) {

package/dist/commands/dev.js

@@ -1,9 +1,9 @@
 import { createRequire } from "node:module";
-import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
 import * as p from "@clack/prompts";
 import chalk from "chalk";
 import fs from "fs-extra";
+import { existsSync } from "node:fs";
 import { fork } from "node:child_process";
 import open from "open";
 

package/dist/commands/init.js

@@ -3,10 +3,10 @@ import { DEFAULT_PROFILES_CONFIG, LOCAL_REMOTE } from "../utils/profiles/types.j
 import { ProfileManager } from "../utils/profiles/profile-manager.js";
 import "../utils/profiles/index.js";
 import { loginCommand } from "./login.js";
-import { existsSync, mkdirSync, readdirSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 import * as p from "@clack/prompts";
 import chalk from "chalk";
+import { existsSync, mkdirSync, readdirSync, writeFileSync } from "node:fs";
 
 //#region src/commands/init.ts
 /**

package/dist/commands/{pull-v3 → pull-v4}/component-parser.js

@@ -1,9 +1,10 @@
-import { ComponentRegistry } from "./utils/component-registry.js";
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { ComponentRegistry } from "./component-registry.js";
+import { createInMemoryProject } from "./utils.js";
 import { extname, join, relative } from "node:path";
-import { Node, Project } from "ts-morph";
+import { Node } from "ts-morph";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 
-//#region src/commands/pull-v3/component-parser.ts
+//#region src/commands/pull-v4/component-parser.ts
 /**
 * Component Parser - Find all component definitions (exported and inline)
 * Uses AST parsing to handle complex components including those with render attributes
@@ -58,14 +59,7 @@ function parseFileForComponents(filePath, projectRoot, debug = false) {
 	const relativePath = relative(projectRoot, filePath);
 	try {
 		const content = readFileSync(filePath, "utf8");
-		const sourceFile = new Project({
-			useInMemoryFileSystem: true,
-			compilerOptions: {
-				allowJs: true,
-				target: 99,
-				jsx: 1
-			}
-		}).createSourceFile("temp.ts", content);
+		const sourceFile = createInMemoryProject().createSourceFile("temp.ts", content);
 		const exportedVariableDeclarations = sourceFile.getVariableStatements().filter((statement) => statement.hasExportKeyword()).flatMap((statement) => statement.getDeclarationList().getDeclarations());
 		for (const declaration of exportedVariableDeclarations) {
 			const variableName = declaration.getName();

package/dist/commands/{pull-v3/utils → pull-v4}/component-registry.js

@@ -1,4 +1,4 @@
-//#region src/commands/pull-v3/utils/component-registry.ts
+//#region src/commands/pull-v4/component-registry.ts
 var ComponentRegistry = class {
 	components = /* @__PURE__ */ new Map();
 	componentsByTypeAndId = /* @__PURE__ */ new Map();

package/dist/commands/pull-v4/generators/agent-generator.js

@@ -0,0 +1,258 @@
+import { addObjectEntries, addReferenceGetterProperty, addStringProperty, collectTemplateVariableNames, createFactoryDefinition, createUniqueReferenceName, formatStringLiteral, formatTemplate, isPlainObject, toCamelCase } from "../utils.js";
+import { z } from "zod";
+import { SyntaxKind } from "ts-morph";
+
+//#region src/commands/pull-v4/generators/agent-generator.ts
+const SubAgentReferenceSchema = z.object({
+	name: z.string().nonempty(),
+	local: z.boolean().optional()
+});
+const AgentSchema = z.looseObject({
+	agentId: z.string().nonempty(),
+	name: z.string().nonempty(),
+	description: z.string().nullish(),
+	prompt: z.string().optional(),
+	models: z.looseObject({}).optional(),
+	defaultSubAgentId: z.string().nonempty(),
+	subAgents: z.union([z.array(z.string()), z.record(z.string(), z.unknown())]),
+	contextConfig: z.union([z.string(), z.looseObject({ id: z.string().optional() })]).optional(),
+	stopWhen: z.object({ transferCountIs: z.int().optional() }).optional(),
+	statusUpdates: z.strictObject({
+		numEvents: z.int().optional(),
+		timeInSeconds: z.int().optional(),
+		statusComponents: z.array(z.union([z.string(), z.looseObject({
+			id: z.string().optional(),
+			type: z.string(),
+			name: z.string().optional()
+		})])).optional(),
+		prompt: z.string().optional()
+	}).optional(),
+	credentials: z.array(z.union([z.string(), z.strictObject({ id: z.string() })])).optional(),
+	triggers: z.union([z.array(z.string()), z.record(z.string(), z.unknown())]).optional(),
+	agentVariableName: z.string().nonempty().optional(),
+	subAgentReferences: z.record(z.string(), SubAgentReferenceSchema).optional(),
+	contextConfigReference: SubAgentReferenceSchema.optional(),
+	contextConfigHeadersReference: SubAgentReferenceSchema.optional()
+});
+function generateAgentDefinition(data) {
+	const result = AgentSchema.safeParse(data);
+	if (!result.success) throw new Error(`Validation failed for agent:\n${z.prettifyError(result.error)}`);
+	const parsed = result.data;
+	const subAgentIds = new Set(extractIds(parsed.subAgents));
+	subAgentIds.add(parsed.defaultSubAgentId);
+	const agentVarName = parsed.agentVariableName || toCamelCase(parsed.agentId);
+	const { sourceFile, configObject } = createFactoryDefinition({
+		importName: "agent",
+		variableName: agentVarName
+	});
+	const reservedReferenceNames = new Set([agentVarName]);
+	const { referenceNames: subAgentReferenceNames, importNames: subAgentImportNames } = createSubAgentReferenceMaps(subAgentIds, reservedReferenceNames, "SubAgent", parsed.subAgentReferences);
+	addSubAgentImports(sourceFile, subAgentReferenceNames, subAgentImportNames);
+	const contextConfigId = extractContextConfigId(parsed.contextConfig);
+	let contextConfigReferenceName;
+	let contextHeadersReferenceName;
+	const hasHeadersTemplateVariables = collectTemplateVariableNamesFromFields([parsed.prompt, parsed.statusUpdates?.prompt]).some((variableName) => variableName.startsWith("headers."));
+	if (contextConfigId) {
+		const contextConfigImportName = parsed.contextConfigReference?.name ?? toCamelCase(contextConfigId);
+		contextConfigReferenceName = createUniqueReferenceName(contextConfigImportName, reservedReferenceNames, "ContextConfig");
+		const contextHeadersImportName = parsed.contextConfigHeadersReference?.name ?? `${toCamelCase(contextConfigId)}Headers`;
+		if (hasHeadersTemplateVariables) contextHeadersReferenceName = createUniqueReferenceName(contextHeadersImportName, reservedReferenceNames, "Headers");
+		const namedImports = [];
+		if (parsed.contextConfigReference?.local !== true) namedImports.push(contextConfigImportName === contextConfigReferenceName ? contextConfigImportName : {
+			name: contextConfigImportName,
+			alias: contextConfigReferenceName
+		});
+		if (hasHeadersTemplateVariables && contextHeadersReferenceName && parsed.contextConfigHeadersReference?.local !== true) namedImports.push(contextHeadersImportName === contextHeadersReferenceName ? contextHeadersImportName : {
+			name: contextHeadersImportName,
+			alias: contextHeadersReferenceName
+		});
+		if (namedImports.length > 0) sourceFile.addImportDeclaration({
+			namedImports,
+			moduleSpecifier: `../context-configs/${contextConfigId}`
+		});
+	}
+	const triggerReferenceNames = createReferenceNameMap(parsed.triggers ? extractIds(parsed.triggers) : [], reservedReferenceNames, "Trigger");
+	addTriggerImports(sourceFile, triggerReferenceNames);
+	const statusComponentReferenceNames = createReferenceNameMap(extractStatusComponentIds(parsed.statusUpdates), reservedReferenceNames, "StatusComponent");
+	addStatusComponentImports(sourceFile, statusComponentReferenceNames);
+	writeAgentConfig(configObject, parsed, {
+		subAgents: subAgentReferenceNames,
+		contextConfig: contextConfigReferenceName,
+		contextHeaders: contextHeadersReferenceName,
+		triggers: triggerReferenceNames,
+		statusComponents: statusComponentReferenceNames
+	});
+	return sourceFile;
+}
+function writeAgentConfig(configObject, data, referenceNames) {
+	addStringProperty(configObject, "id", data.agentId);
+	addStringProperty(configObject, "name", data.name);
+	if (data.description != null) addStringProperty(configObject, "description", data.description);
+	if (data.prompt !== void 0) {
+		const template = formatTemplate(data.prompt, {
+			contextReference: referenceNames.contextConfig,
+			headersReference: referenceNames.contextHeaders
+		});
+		configObject.addPropertyAssignment({
+			name: "prompt",
+			initializer: formatStringLiteral(template)
+		});
+	}
+	if (data.models && Object.keys(data.models).length > 0) addObjectEntries(configObject.addPropertyAssignment({
+		name: "models",
+		initializer: "{}"
+	}).getInitializerIfKindOrThrow(SyntaxKind.ObjectLiteralExpression), data.models);
+	configObject.addPropertyAssignment({
+		name: "defaultSubAgent",
+		initializer: referenceNames.subAgents.get(data.defaultSubAgentId) ?? toCamelCase(data.defaultSubAgentId)
+	});
+	addReferenceGetterProperty(configObject, "subAgents", extractIds(data.subAgents).map((id) => referenceNames.subAgents.get(id) ?? toCamelCase(id)));
+	if (extractContextConfigId(data.contextConfig) && referenceNames.contextConfig) configObject.addPropertyAssignment({
+		name: "contextConfig",
+		initializer: referenceNames.contextConfig
+	});
+	if (data.credentials?.length) {
+		const credentialIds = data.credentials.map((credential) => {
+			if (typeof credential === "string") return credential;
+			return credential.id;
+		}).filter((id) => Boolean(id));
+		if (credentialIds.length > 0) addReferenceGetterProperty(configObject, "credentials", credentialIds.map((id) => toCamelCase(id)));
+	}
+	const triggerIds = data.triggers ? extractIds(data.triggers) : [];
+	if (triggerIds.length > 0) addReferenceGetterProperty(configObject, "triggers", triggerIds.map((id) => referenceNames.triggers.get(id) ?? toCamelCase(id)));
+	if (data.stopWhen?.transferCountIs !== void 0) configObject.addPropertyAssignment({
+		name: "stopWhen",
+		initializer: "{}"
+	}).getInitializerIfKindOrThrow(SyntaxKind.ObjectLiteralExpression).addPropertyAssignment({
+		name: "transferCountIs",
+		initializer: String(data.stopWhen.transferCountIs)
+	});
+	if (data.statusUpdates) {
+		const statusUpdatesObject = configObject.addPropertyAssignment({
+			name: "statusUpdates",
+			initializer: "{}"
+		}).getInitializerIfKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+		if (data.statusUpdates.numEvents !== void 0) statusUpdatesObject.addPropertyAssignment({
+			name: "numEvents",
+			initializer: String(data.statusUpdates.numEvents)
+		});
+		if (data.statusUpdates.timeInSeconds !== void 0) statusUpdatesObject.addPropertyAssignment({
+			name: "timeInSeconds",
+			initializer: String(data.statusUpdates.timeInSeconds)
+		});
+		if (data.statusUpdates.statusComponents && data.statusUpdates.statusComponents.length > 0) {
+			const statusComponentRefs = data.statusUpdates.statusComponents.map((statusComponent) => `${referenceNames.statusComponents.get(resolveStatusComponentId(statusComponent)) ?? toCamelCase(resolveStatusComponentId(statusComponent))}.config`);
+			if (statusComponentRefs.length > 0) statusUpdatesObject.addPropertyAssignment({
+				name: "statusComponents",
+				initializer: "[]"
+			}).getInitializerIfKindOrThrow(SyntaxKind.ArrayLiteralExpression).addElements(statusComponentRefs);
+		}
+		if (data.statusUpdates.prompt !== void 0) {
+			const template = formatTemplate(data.statusUpdates.prompt, {
+				contextReference: referenceNames.contextConfig,
+				headersReference: referenceNames.contextHeaders
+			});
+			statusUpdatesObject.addPropertyAssignment({
+				name: "prompt",
+				initializer: formatStringLiteral(template)
+			});
+		}
+	}
+}
+function collectTemplateVariableNamesFromFields(values) {
+	const variables = [];
+	for (const value of values) {
+		if (typeof value !== "string") continue;
+		variables.push(...collectTemplateVariableNames(value));
+	}
+	return variables;
+}
+function extractIds(value) {
+	if (Array.isArray(value)) return value.map((item) => {
+		if (typeof item === "string") return item;
+		if (isPlainObject(item) && typeof item.id === "string") return item.id;
+		return null;
+	}).filter((id) => !!id);
+	return Object.keys(value);
+}
+function extractContextConfigId(contextConfig) {
+	if (!contextConfig) return;
+	if (typeof contextConfig === "string") return contextConfig;
+	return contextConfig.id;
+}
+function addSubAgentImports(sourceFile, referenceNames, importNames) {
+	for (const [subAgentId, referenceName] of referenceNames) {
+		const importName = importNames.get(subAgentId);
+		if (!importName) continue;
+		sourceFile.addImportDeclaration({
+			namedImports: [importName === referenceName ? importName : {
+				name: importName,
+				alias: referenceName
+			}],
+			moduleSpecifier: `./sub-agents/${subAgentId}`
+		});
+	}
+}
+function addTriggerImports(sourceFile, referenceNames) {
+	for (const [triggerId, referenceName] of referenceNames) {
+		const importName = toCamelCase(triggerId);
+		sourceFile.addImportDeclaration({
+			namedImports: [importName === referenceName ? importName : {
+				name: importName,
+				alias: referenceName
+			}],
+			moduleSpecifier: `./triggers/${triggerId}`
+		});
+	}
+}
+function extractStatusComponentIds(statusUpdates) {
+	if (!statusUpdates?.statusComponents?.length) return [];
+	const statusComponentIds = statusUpdates.statusComponents.map(resolveStatusComponentId);
+	return [...new Set(statusComponentIds)];
+}
+function resolveStatusComponentId(statusComponent) {
+	const id = typeof statusComponent === "string" ? statusComponent : statusComponent.id || statusComponent.type;
+	if (!id) throw new Error(`Unable to resolve status component with id ${JSON.stringify(statusComponent)}`);
+	return id;
+}
+function addStatusComponentImports(sourceFile, referenceNames) {
+	for (const [statusComponentId, referenceName] of referenceNames) {
+		const importName = toCamelCase(statusComponentId);
+		sourceFile.addImportDeclaration({
+			namedImports: [importName === referenceName ? importName : {
+				name: importName,
+				alias: referenceName
+			}],
+			moduleSpecifier: `../status-components/${statusComponentId}`
+		});
+	}
+}
+function createSubAgentReferenceMaps(ids, reservedNames, conflictSuffix, overrides) {
+	const referenceNames = /* @__PURE__ */ new Map();
+	const importNames = /* @__PURE__ */ new Map();
+	for (const id of ids) {
+		if (referenceNames.has(id)) continue;
+		const override = overrides?.[id];
+		const importName = override?.name ?? toCamelCase(id);
+		const isLocal = override?.local === true;
+		const referenceName = isLocal ? importName : createUniqueReferenceName(importName, reservedNames, conflictSuffix);
+		if (isLocal) reservedNames.add(referenceName);
+		else importNames.set(id, importName);
+		referenceNames.set(id, referenceName);
+	}
+	return {
+		referenceNames,
+		importNames
+	};
+}
+function createReferenceNameMap(ids, reservedNames, conflictSuffix) {
+	const map = /* @__PURE__ */ new Map();
+	for (const id of ids) {
+		if (map.has(id)) continue;
+		map.set(id, createUniqueReferenceName(toCamelCase(id), reservedNames, conflictSuffix));
+	}
+	return map;
+}
+
+//#endregion
+export { generateAgentDefinition };

package/dist/commands/pull-v4/generators/artifact-component-generator.js

@@ -0,0 +1,69 @@
+import { addValueToObject, convertJsonSchemaToZodSafe, convertNullToUndefined, createFactoryDefinition, formatPropertyName, formatStringLiteral, isPlainObject, toCamelCase } from "../utils.js";
+import { z } from "zod";
+
+//#region src/commands/pull-v4/generators/artifact-component-generator.ts
+const ArtifactComponentSchema = z.object({
+	artifactComponentId: z.string().nonempty(),
+	name: z.string().nonempty(),
+	description: z.string().optional(),
+	props: z.looseObject({}),
+	schema: z.looseObject({}).optional(),
+	template: z.string().optional(),
+	contentType: z.string().optional(),
+	render: z.preprocess(convertNullToUndefined, z.looseObject({
+		component: z.string().optional(),
+		mockData: z.looseObject({}).optional()
+	}).optional())
+});
+function generateArtifactComponentDefinition(data) {
+	const result = ArtifactComponentSchema.safeParse(data);
+	if (!result.success) throw new Error(`Validation failed for artifact component:\n${z.prettifyError(result.error)}`);
+	const parsed = result.data;
+	const schema = parsed.props ?? parsed.schema;
+	const { sourceFile, configObject } = createFactoryDefinition({
+		importName: "artifactComponent",
+		variableName: toCamelCase(parsed.artifactComponentId)
+	});
+	if (hasInPreviewFields(schema)) sourceFile.addImportDeclaration({
+		namedImports: ["preview"],
+		moduleSpecifier: "@inkeep/agents-core"
+	});
+	if (schema) sourceFile.addImportDeclaration({
+		namedImports: ["z"],
+		moduleSpecifier: "zod"
+	});
+	const { artifactComponentId, schema: _, props: _2, ...rest } = parsed;
+	for (const [key, value] of Object.entries({
+		id: artifactComponentId,
+		...rest
+	})) addValueToObject(configObject, key, value);
+	if (schema) configObject.addPropertyAssignment({
+		name: "props",
+		initializer: formatArtifactSchema(schema)
+	});
+	return sourceFile;
+}
+function hasInPreviewFields(schema) {
+	if (!isPlainObject(schema) || schema.type !== "object" || !isPlainObject(schema.properties)) return false;
+	return Object.values(schema.properties).some((property) => isPlainObject(property) && property.inPreview === true);
+}
+function formatArtifactSchema(schema) {
+	if (!isPlainObject(schema)) return "z.any()";
+	if (schema.type === "object" && isPlainObject(schema.properties)) {
+		const lines = ["z.object({"];
+		for (const [key, propertySchema] of Object.entries(schema.properties)) {
+			const propertyWithoutPreview = isPlainObject(propertySchema) ? { ...propertySchema } : propertySchema;
+			if (isPlainObject(propertyWithoutPreview)) delete propertyWithoutPreview.inPreview;
+			const zodType = convertJsonSchemaToZodSafe(propertyWithoutPreview);
+			const propertyValue = isPlainObject(propertySchema) && propertySchema.inPreview === true ? `preview(${zodType})` : zodType;
+			lines.push(`  ${formatPropertyName(key)}: ${propertyValue},`);
+		}
+		lines.push("})");
+		if (typeof schema.description === "string") return `${lines.join("\n")}.describe(${formatStringLiteral(schema.description)})`;
+		return lines.join("\n");
+	}
+	return convertJsonSchemaToZodSafe(schema);
+}
+
+//#endregion
+export { generateArtifactComponentDefinition };

package/dist/commands/pull-v4/generators/context-config-generator.js

@@ -0,0 +1,264 @@
+import { addFactoryConfigVariable, addStringProperty, addValueToObject, convertJsonSchemaToZodSafe, convertNullToUndefined, createInMemoryProject, formatPropertyName, isPlainObject, toCamelCase } from "../utils.js";
+import { z } from "zod";
+import { SyntaxKind } from "ts-morph";
+
+//#region src/commands/pull-v4/generators/context-config-generator.ts
+const ReferenceNameByIdSchema = z.record(z.string(), z.string().nonempty());
+const ReferenceOverridesSchema = z.object({ credentialReferences: ReferenceNameByIdSchema.optional() });
+const ContextConfigSchema = z.looseObject({
+	contextConfigId: z.string().nonempty(),
+	id: z.string().optional(),
+	schema: z.looseObject({}).optional(),
+	headers: z.union([z.string(), z.looseObject({ id: z.string().optional() })]).optional(),
+	headersSchema: z.preprocess(convertNullToUndefined, z.looseObject({}).optional()),
+	contextVariables: z.record(z.string(), z.unknown()).optional(),
+	referenceOverrides: ReferenceOverridesSchema.optional()
+});
+function generateContextConfigDefinition(data) {
+	const result = ContextConfigSchema.safeParse(data);
+	if (!result.success) throw new Error(`Validation failed for context config:\n${z.prettifyError(result.error)}`);
+	const project = createInMemoryProject();
+	const parsed = result.data;
+	const sourceFile = project.createSourceFile("context-config-definition.ts", "", { overwrite: true });
+	if (isHeadersDefinitionData(parsed)) return generateStandaloneHeadersDefinition(sourceFile, parsed);
+	if (isFetchDefinitionData(parsed)) return generateStandaloneFetchDefinition(sourceFile, parsed);
+	const parsedContextConfig = result.data;
+	const explicitHeadersReference = extractHeadersReference(parsedContextConfig.headers);
+	const templateHeaderVariables = collectTemplateHeaderVariables(parsedContextConfig.contextVariables);
+	const inferredHeadersSchema = !isPlainObject(parsedContextConfig.headersSchema) && !explicitHeadersReference ? inferHeadersSchemaFromTemplateHeaderVariables(templateHeaderVariables) : void 0;
+	const headersSchema = isPlainObject(parsedContextConfig.headersSchema) ? parsedContextConfig.headersSchema : inferredHeadersSchema;
+	const headersReference = resolveHeadersReference(parsedContextConfig, Boolean(headersSchema));
+	const shouldDefineHeadersInFile = Boolean(headersReference) && isPlainObject(headersSchema);
+	const fetchDefinitions = collectFetchDefinitionEntries(parsedContextConfig.contextVariables);
+	const credentialReferenceNames = collectCredentialReferenceNames(fetchDefinitions, parsedContextConfig.referenceOverrides?.credentialReferences);
+	const coreImports = ["contextConfig"];
+	if (shouldDefineHeadersInFile) coreImports.unshift("headers");
+	if (fetchDefinitions.length > 0) coreImports.splice(coreImports.length - 1, 0, "fetchDefinition");
+	sourceFile.addImportDeclaration({
+		namedImports: coreImports,
+		moduleSpecifier: "@inkeep/agents-core"
+	});
+	const hasResponseSchemas = fetchDefinitions.some((definition) => isPlainObject(definition.data.responseSchema));
+	if (shouldDefineHeadersInFile || hasResponseSchemas) sourceFile.addImportDeclaration({
+		namedImports: ["z"],
+		moduleSpecifier: "zod"
+	});
+	for (const [credentialId, credentialReferenceName] of credentialReferenceNames) sourceFile.addImportDeclaration({
+		namedImports: [credentialReferenceName],
+		moduleSpecifier: `../credentials/${credentialId}`
+	});
+	if (shouldDefineHeadersInFile && headersReference && headersSchema) {
+		const { configObject: headersObject } = addFactoryConfigVariable({
+			sourceFile,
+			importName: "headers",
+			variableName: headersReference
+		});
+		headersObject.addPropertyAssignment({
+			name: "schema",
+			initializer: convertJsonSchemaToZod(headersSchema)
+		});
+	}
+	for (const fetchDefinition of fetchDefinitions) {
+		const { configObject: fetchConfigObject } = addFactoryConfigVariable({
+			sourceFile,
+			importName: "fetchDefinition",
+			variableName: fetchDefinition.variableName
+		});
+		writeFetchDefinition(fetchConfigObject, fetchDefinition.data, credentialReferenceNames, headersReference);
+	}
+	const { configObject } = addFactoryConfigVariable({
+		sourceFile,
+		importName: "contextConfig",
+		variableName: toContextConfigVariableName(parsedContextConfig.contextConfigId),
+		isExported: true
+	});
+	writeContextConfig(configObject, parsedContextConfig, headersReference);
+	return sourceFile;
+}
+function writeContextConfig(configObject, data, headersReference) {
+	if (data.id !== void 0) addStringProperty(configObject, "id", data.id);
+	if (headersReference) configObject.addPropertyAssignment({
+		name: "headers",
+		initializer: headersReference
+	});
+	if (data.contextVariables && Object.keys(data.contextVariables).length > 0) {
+		const contextVariablesObject = configObject.addPropertyAssignment({
+			name: "contextVariables",
+			initializer: "{}"
+		}).getInitializerIfKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+		for (const [key, value] of Object.entries(data.contextVariables)) {
+			const reference = extractContextVariableReference(key, value);
+			if (!reference) continue;
+			contextVariablesObject.addPropertyAssignment({
+				name: formatPropertyName(key),
+				initializer: reference
+			});
+		}
+	}
+}
+function extractHeadersReference(headers) {
+	if (!headers) return;
+	if (typeof headers === "string") return headers;
+	if (typeof headers.id === "string") return headers.id;
+	if (typeof headers.name === "string") return headers.name;
+}
+function resolveHeadersReference(data, hasHeadersSchema) {
+	const headersRef = extractHeadersReference(data.headers);
+	if (headersRef) return toReferenceIdentifier(headersRef);
+	if (hasHeadersSchema) return `${toContextConfigVariableName(data.contextConfigId)}Headers`;
+}
+function isFetchDefinitionData(value) {
+	if (!isPlainObject(value)) return false;
+	return value.fetchConfig !== void 0 || value.responseSchema !== void 0;
+}
+function collectFetchDefinitionEntries(contextVariables) {
+	if (!contextVariables) return [];
+	return Object.entries(contextVariables).filter(([, value]) => isFetchDefinitionData(value)).map(([key, value]) => {
+		return {
+			key,
+			variableName: extractContextVariableReference(key, value) ?? toReferenceIdentifier(key),
+			data: value
+		};
+	});
+}
+function writeFetchDefinition(configObject, fetchDefinitionData, credentialReferenceNames, headersReference) {
+	const { contextConfigId, responseSchema, credentialReferenceId, ...rest } = isPlainObject(fetchDefinitionData) ? fetchDefinitionData : {};
+	const normalizedRest = rewriteHeaderTemplates(rest, headersReference);
+	for (const [k, v] of Object.entries({
+		id: contextConfigId,
+		...normalizedRest
+	})) if (v !== null) addValueToObject(configObject, k, v);
+	if (responseSchema) configObject.addPropertyAssignment({
+		name: "responseSchema",
+		initializer: convertJsonSchemaToZod(responseSchema)
+	});
+	if (typeof credentialReferenceId === "string" && credentialReferenceNames?.has(credentialReferenceId)) {
+		configObject.addPropertyAssignment({
+			name: "credentialReference",
+			initializer: credentialReferenceNames.get(credentialReferenceId)
+		});
+		return;
+	}
+	if (typeof credentialReferenceId === "string") addStringProperty(configObject, "credentialReferenceId", credentialReferenceId);
+}
+const HEADER_TEMPLATE_REGEX = /\{\{headers\.([^}]+)\}\}/g;
+const HEADER_TO_TEMPLATE_CALL_REGEX = /\$\{\s*(headersSchema|headers)\.toTemplate\((['"])([^'"`]+)\2\)\s*\}/g;
+function rewriteHeaderTemplates(value, headersReference) {
+	if (!headersReference) return value;
+	if (typeof value === "string") return value.replace(HEADER_TEMPLATE_REGEX, (_, variableName) => {
+		return `\${${headersReference}.toTemplate(${JSON.stringify(variableName)})}`;
+	}).replace(HEADER_TO_TEMPLATE_CALL_REGEX, (_, __, ___, variableName) => {
+		return `\${${headersReference}.toTemplate(${JSON.stringify(variableName)})}`;
+	});
+	if (Array.isArray(value)) return value.map((entry) => rewriteHeaderTemplates(entry, headersReference));
+	if (isPlainObject(value)) return Object.fromEntries(Object.entries(value).map(([key, entryValue]) => [key, rewriteHeaderTemplates(entryValue, headersReference)]));
+	return value;
+}
+function generateStandaloneHeadersDefinition(sourceFile, data) {
+	const importName = "headers";
+	sourceFile.addImportDeclaration({
+		namedImports: [importName],
+		moduleSpecifier: "@inkeep/agents-core"
+	});
+	sourceFile.addImportDeclaration({
+		namedImports: ["z"],
+		moduleSpecifier: "zod"
+	});
+	const { configObject } = addFactoryConfigVariable({
+		sourceFile,
+		importName,
+		variableName: toContextConfigVariableName(data.contextConfigId)
+	});
+	configObject.addPropertyAssignment({
+		name: "schema",
+		initializer: convertJsonSchemaToZod(data.schema)
+	});
+	return sourceFile;
+}
+function isHeadersDefinitionData(value) {
+	return isPlainObject(value.schema);
+}
+function generateStandaloneFetchDefinition(sourceFile, data) {
+	const importName = "fetchDefinition";
+	sourceFile.addImportDeclaration({
+		namedImports: [importName],
+		moduleSpecifier: "@inkeep/agents-core"
+	});
+	if (isPlainObject(data.responseSchema)) sourceFile.addImportDeclaration({
+		namedImports: ["z"],
+		moduleSpecifier: "zod"
+	});
+	const credentialReferenceNames = /* @__PURE__ */ new Map();
+	if (typeof data.credentialReferenceId === "string") {
+		const credentialReferenceId = data.credentialReferenceId;
+		const credentialReferenceName = data.referenceOverrides?.credentialReferences?.[credentialReferenceId] ?? toReferenceIdentifier(credentialReferenceId);
+		credentialReferenceNames.set(credentialReferenceId, credentialReferenceName);
+		sourceFile.addImportDeclaration({
+			namedImports: [credentialReferenceName],
+			moduleSpecifier: `../credentials/${credentialReferenceId}`
+		});
+	}
+	const { configObject } = addFactoryConfigVariable({
+		sourceFile,
+		importName,
+		variableName: toContextConfigVariableName(data.contextConfigId)
+	});
+	writeFetchDefinition(configObject, data, credentialReferenceNames);
+	return sourceFile;
+}
+function convertJsonSchemaToZod(schema) {
+	return convertJsonSchemaToZodSafe(schema, { conversionOptions: { module: "none" } });
+}
+function extractContextVariableReference(key, value) {
+	if (typeof value === "string") return toReferenceIdentifier(value);
+	if (!isPlainObject(value)) return;
+	if (typeof value.id === "string") return toReferenceIdentifier(value.id);
+	if (typeof value.name === "string") return toReferenceIdentifier(value.name);
+	if (typeof value.ref === "string") return toReferenceIdentifier(value.ref);
+	if (typeof value.variable === "string") return toReferenceIdentifier(value.variable);
+	if (value.fetchConfig || value.responseSchema) return toReferenceIdentifier(key);
+	return toReferenceIdentifier(key);
+}
+const toContextConfigVariableName = toCamelCase;
+const toReferenceIdentifier = toCamelCase;
+function collectCredentialReferenceNames(fetchDefinitions, overrideNamesById) {
+	const credentialReferenceNames = /* @__PURE__ */ new Map();
+	for (const fetchDefinition of fetchDefinitions) {
+		const fetchDefinitionData = isPlainObject(fetchDefinition.data) ? fetchDefinition.data : void 0;
+		const credentialReferenceId = fetchDefinitionData && typeof fetchDefinitionData.credentialReferenceId === "string" ? fetchDefinitionData.credentialReferenceId : void 0;
+		if (!credentialReferenceId || credentialReferenceNames.has(credentialReferenceId)) continue;
+		credentialReferenceNames.set(credentialReferenceId, overrideNamesById?.[credentialReferenceId] ?? toReferenceIdentifier(credentialReferenceId));
+	}
+	return credentialReferenceNames;
+}
+function collectTemplateHeaderVariables(contextVariables) {
+	const variables = /* @__PURE__ */ new Set();
+	collectTemplateHeaderVariablesFromValue(contextVariables, variables);
+	return variables;
+}
+function collectTemplateHeaderVariablesFromValue(value, variables) {
+	if (typeof value === "string") {
+		for (const match of value.matchAll(HEADER_TEMPLATE_REGEX)) if (match[1]) variables.add(match[1]);
+		for (const match of value.matchAll(HEADER_TO_TEMPLATE_CALL_REGEX)) if (match[3]) variables.add(match[3]);
+		return;
+	}
+	if (Array.isArray(value)) {
+		for (const entry of value) collectTemplateHeaderVariablesFromValue(entry, variables);
+		return;
+	}
+	if (isPlainObject(value)) for (const entryValue of Object.values(value)) collectTemplateHeaderVariablesFromValue(entryValue, variables);
+}
+function inferHeadersSchemaFromTemplateHeaderVariables(variables) {
+	if (!variables.size) return;
+	const properties = {};
+	for (const variable of [...variables].sort()) properties[variable] = { type: "string" };
+	return {
+		type: "object",
+		properties,
+		required: [...variables].sort(),
+		additionalProperties: false
+	};
+}
+
+//#endregion
+export { generateContextConfigDefinition };