@inkeep/agents-cli 0.39.4 → 0.40.0

package/dist/commands/pull-v3/components/agent-generator.js

@@ -0,0 +1,241 @@
+import { compareJsonObjects } from "../../../utils/json-comparator.js";
+import { DEFAULT_STYLE, formatPromptWithContext, formatString, generateFileContent, generateImport, hasTemplateVariables, removeTrailingComma, toCamelCase } from "../utils/generator-utils.js";
+
+//#region src/commands/pull-v3/components/agent-generator.ts
+/**
+* Agent Generator - Generate top-level agent definitions
+*
+* Generates top-level agents using the agent() builder function from @inkeep/agents-sdk
+* Top-level agents are the main entry points that handle statusUpdates with statusComponents
+*/
+/**
+* Format statusUpdates configuration with statusComponents references
+*/
+function formatStatusUpdates(statusUpdatesConfig, style, indentLevel, registry, contextConfigData, agentId) {
+	if (!statusUpdatesConfig) return "";
+	const { quotes, indentation } = style;
+	const q = quotes === "single" ? "'" : "\"";
+	const indent = indentation.repeat(indentLevel);
+	const lines = [];
+	lines.push(`${indent}statusUpdates: {`);
+	if (statusUpdatesConfig.numEvents !== void 0) lines.push(`${indent}${indentation}numEvents: ${statusUpdatesConfig.numEvents},`);
+	if (statusUpdatesConfig.timeInSeconds !== void 0) lines.push(`${indent}${indentation}timeInSeconds: ${statusUpdatesConfig.timeInSeconds},`);
+	if (statusUpdatesConfig.statusComponents && Array.isArray(statusUpdatesConfig.statusComponents) && statusUpdatesConfig.statusComponents.length > 0) {
+		const statusComponentIds = statusUpdatesConfig.statusComponents.map((comp) => {
+			if (typeof comp === "string") return comp;
+			if (typeof comp === "object" && comp) return comp.id || comp.type || comp.name;
+			return null;
+		}).filter(Boolean);
+		if (statusComponentIds.length > 0) {
+			lines.push(`${indent}${indentation}statusComponents: [`);
+			for (const statusCompId of statusComponentIds) {
+				const statusCompVar = registry?.getVariableName(statusCompId, "statusComponents");
+				lines.push(`${indent}${indentation}${indentation}${statusCompVar || "undefined"}.config,`);
+			}
+			lines.push(`${indent}${indentation}],`);
+		}
+	}
+	if (statusUpdatesConfig.prompt) if (hasTemplateVariables(statusUpdatesConfig.prompt) && contextConfigData && agentId && registry) {
+		const contextConfigId = contextConfigData.id;
+		const contextVarName = registry.getVariableName(contextConfigId, "contextConfigs");
+		if (!contextVarName) throw new Error(`Failed to resolve context config variable name for: ${contextConfigId}`);
+		lines.push(`${indent}${indentation}prompt: ${formatPromptWithContext(statusUpdatesConfig.prompt, contextVarName, "headersSchema", contextConfigData, q, true)},`);
+	} else lines.push(`${indent}${indentation}prompt: ${formatString(statusUpdatesConfig.prompt, q, true)},`);
+	removeTrailingComma(lines);
+	lines.push(`${indent}},`);
+	return lines.join("\n");
+}
+/**
+* Format stopWhen configuration for agents (only supports transferCountIs)
+*/
+function formatStopWhen(stopWhenConfig, style, indentLevel) {
+	if (!stopWhenConfig || !stopWhenConfig.transferCountIs) return "";
+	const { indentation } = style;
+	const indent = indentation.repeat(indentLevel);
+	return `${indent}stopWhen: {\n${indent}${indentation}transferCountIs: ${stopWhenConfig.transferCountIs} // Max transfers in one conversation\n${indent}},`;
+}
+/**
+* Check if agent models are different from project models
+*/
+function hasDistinctModels(agentModels, projectModels) {
+	if (!agentModels) return false;
+	if (!projectModels) return !!agentModels;
+	for (const type of [
+		"base",
+		"structuredOutput",
+		"summarizer"
+	]) {
+		const agentModel = agentModels[type]?.model;
+		const projectModel = projectModels[type]?.model;
+		if (agentModel !== projectModel) return true;
+		if (agentModel && projectModel) {
+			const agentOptions = agentModels[type]?.providerOptions;
+			const projectOptions = projectModels[type]?.providerOptions;
+			if (agentOptions !== projectOptions) {
+				if (!agentOptions && !projectOptions) continue;
+				if (!agentOptions || !projectOptions) return true;
+				if (!compareJsonObjects(agentOptions, projectOptions, {
+					ignoreArrayOrder: true,
+					showDetails: false
+				}).isEqual) return true;
+			}
+		}
+	}
+	return false;
+}
+/**
+* Generate Agent Definition using agent() builder function
+*/
+function generateAgentDefinition(agentId, agentData, style = DEFAULT_STYLE, registry, contextConfigData, projectModels) {
+	if (!agentId || typeof agentId !== "string") throw new Error("agentId is required and must be a string");
+	if (!agentData || typeof agentData !== "object") throw new Error(`agentData is required for agent '${agentId}'`);
+	const missingFields = [
+		"name",
+		"defaultSubAgentId",
+		"subAgents"
+	].filter((field) => !agentData[field] || agentData[field] === null || agentData[field] === void 0);
+	if (missingFields.length > 0) throw new Error(`Missing required fields for agent '${agentId}': ${missingFields.join(", ")}`);
+	const { quotes, semicolons, indentation } = style;
+	const q = quotes === "single" ? "'" : "\"";
+	const semi = semicolons ? ";" : "";
+	let agentVarName = toCamelCase(agentId);
+	if (registry) {
+		const registryVarName = registry.getVariableName(agentId, "agents");
+		if (registryVarName) agentVarName = registryVarName;
+	}
+	const lines = [];
+	lines.push(`export const ${agentVarName} = agent({`);
+	lines.push(`${indentation}id: ${formatString(agentId, q)},`);
+	lines.push(`${indentation}name: ${formatString(agentData.name, q)},`);
+	if (agentData.description !== void 0 && agentData.description !== null) lines.push(`${indentation}description: ${formatString(agentData.description, q, true)},`);
+	if (agentData.prompt !== void 0 && agentData.prompt !== null) if (hasTemplateVariables(agentData.prompt) && contextConfigData && registry) {
+		const contextConfigId = contextConfigData.id;
+		const contextVarName = registry.getVariableName(contextConfigId, "contextConfigs");
+		if (!contextVarName) throw new Error(`Failed to resolve context config variable name for: ${contextConfigId}`);
+		lines.push(`${indentation}prompt: ${formatPromptWithContext(agentData.prompt, contextVarName, "headersSchema", contextConfigData, q, true)},`);
+	} else lines.push(`${indentation}prompt: ${formatString(agentData.prompt, q, true)},`);
+	if (agentData.models && hasDistinctModels(agentData.models, projectModels)) {
+		lines.push(`${indentation}models: {`);
+		if (agentData.models.base?.model) {
+			lines.push(`${indentation}${indentation}base: {`);
+			lines.push(`${indentation}${indentation}${indentation}model: ${formatString(agentData.models.base.model, q)}`);
+			if (agentData.models.base.providerOptions) {
+				lines.push(`${indentation}${indentation}${indentation},`);
+				lines.push(`${indentation}${indentation}${indentation}providerOptions: ${JSON.stringify(agentData.models.base.providerOptions)}`);
+			}
+			lines.push(`${indentation}${indentation}},`);
+		}
+		if (agentData.models.structuredOutput?.model) {
+			lines.push(`${indentation}${indentation}structuredOutput: {`);
+			lines.push(`${indentation}${indentation}${indentation}model: ${formatString(agentData.models.structuredOutput.model, q)}`);
+			if (agentData.models.structuredOutput.providerOptions) {
+				lines.push(`${indentation}${indentation}${indentation},`);
+				lines.push(`${indentation}${indentation}${indentation}providerOptions: ${JSON.stringify(agentData.models.structuredOutput.providerOptions)}`);
+			}
+			lines.push(`${indentation}${indentation}},`);
+		}
+		if (agentData.models.summarizer?.model) {
+			lines.push(`${indentation}${indentation}summarizer: {`);
+			lines.push(`${indentation}${indentation}${indentation}model: ${formatString(agentData.models.summarizer.model, q)}`);
+			if (agentData.models.summarizer.providerOptions) {
+				lines.push(`${indentation}${indentation}${indentation},`);
+				lines.push(`${indentation}${indentation}${indentation}providerOptions: ${JSON.stringify(agentData.models.summarizer.providerOptions)}`);
+			}
+			lines.push(`${indentation}${indentation}},`);
+		}
+		removeTrailingComma(lines);
+		lines.push(`${indentation}},`);
+	}
+	if (agentData.defaultSubAgentId) {
+		if (!registry) throw new Error("Registry is required for defaultSubAgent generation");
+		const defaultSubAgentVar = registry.getVariableName(agentData.defaultSubAgentId, "subAgents");
+		if (!defaultSubAgentVar) throw new Error(`Failed to resolve variable name for default sub-agent: ${agentData.defaultSubAgentId}`);
+		lines.push(`${indentation}defaultSubAgent: ${defaultSubAgentVar},`);
+	}
+	if (agentData.subAgents && typeof agentData.subAgents === "object" && Object.keys(agentData.subAgents).length > 0) {
+		if (!registry) throw new Error("Registry is required for subAgents generation");
+		const subAgentIds = Object.keys(agentData.subAgents);
+		const subAgentsArray = registry.formatReferencesForCode(subAgentIds, "subAgents", style, 2);
+		if (!subAgentsArray) throw new Error(`Failed to resolve variable names for sub-agents: ${subAgentIds.join(", ")}`);
+		lines.push(`${indentation}subAgents: () => ${subAgentsArray},`);
+	}
+	if (agentData.contextConfig && registry && agentData.contextConfig.id) {
+		const contextConfigVar = registry.getVariableName(agentData.contextConfig.id, "contextConfigs");
+		if (contextConfigVar) lines.push(`${indentation}contextConfig: ${contextConfigVar},`);
+		else lines.push(`${indentation}contextConfig: undefined,`);
+	}
+	if (agentData.credentials && Array.isArray(agentData.credentials) && agentData.credentials.length > 0) {
+		if (!registry) throw new Error("Registry is required for credentials generation");
+		const credentialsArray = `[${agentData.credentials.map((cred) => {
+			const credVarName = registry.getVariableName(cred.id, "credentials");
+			if (!credVarName) throw new Error(`Failed to resolve variable name for credential: ${cred.id}`);
+			return credVarName;
+		}).join(", ")}]`;
+		lines.push(`${indentation}credentials: () => ${credentialsArray},`);
+	}
+	if (agentData.stopWhen) {
+		const stopWhenFormatted = formatStopWhen(agentData.stopWhen, style, 1);
+		if (stopWhenFormatted) lines.push(stopWhenFormatted);
+	}
+	if (agentData.statusUpdates) {
+		const statusUpdatesFormatted = formatStatusUpdates(agentData.statusUpdates, style, 1, registry, contextConfigData, agentId);
+		if (statusUpdatesFormatted) lines.push(statusUpdatesFormatted);
+	}
+	removeTrailingComma(lines);
+	lines.push(`})${semi}`);
+	return lines.join("\n");
+}
+/**
+* Generate imports needed for an agent file
+*/
+function generateAgentImports(agentId, agentData, style = DEFAULT_STYLE, registry, contextConfigData, actualFilePath) {
+	const imports = [];
+	imports.push(generateImport(["agent"], "@inkeep/agents-sdk", style));
+	if (registry) {
+		const currentFilePath = actualFilePath || `agents/${agentId}.ts`;
+		const referencedComponents = [];
+		if (agentData.subAgents && typeof agentData.subAgents === "object") {
+			const subAgentIds = Object.keys(agentData.subAgents);
+			referencedComponents.push(...subAgentIds.map((id) => ({
+				id,
+				type: "subAgents"
+			})));
+		}
+		if (agentData.statusUpdates && agentData.statusUpdates.statusComponents && Array.isArray(agentData.statusUpdates.statusComponents)) {
+			for (const comp of agentData.statusUpdates.statusComponents) if (typeof comp === "string") referencedComponents.push({
+				id: comp,
+				type: "statusComponents"
+			});
+			else if (typeof comp === "object" && comp) {
+				const statusId = comp.id || comp.type || comp.name;
+				if (statusId) referencedComponents.push({
+					id: statusId,
+					type: "statusComponents"
+				});
+			}
+		}
+		if (agentData.contextConfig) {
+			const contextConfigId = agentData.contextConfig.id;
+			referencedComponents.push({
+				id: contextConfigId,
+				type: "contextConfigs"
+			});
+		}
+		if (agentData.defaultSubAgentId) referencedComponents.push({
+			id: agentData.defaultSubAgentId,
+			type: "subAgents"
+		});
+		const componentImports = registry.getImportsForFile(currentFilePath, referencedComponents);
+		imports.push(...componentImports);
+	}
+	return imports;
+}
+/**
+* Generate complete agent file (imports + definition)
+*/
+function generateAgentFile(agentId, agentData, style = DEFAULT_STYLE, registry, contextConfigData, projectModels, actualFilePath) {
+	return generateFileContent(generateAgentImports(agentId, agentData, style, registry, contextConfigData, actualFilePath), [generateAgentDefinition(agentId, agentData, style, registry, contextConfigData, projectModels)]);
+}
+
+//#endregion
+export { generateAgentDefinition, generateAgentFile, generateAgentImports };

package/dist/commands/pull-v3/components/artifact-component-generator.js

@@ -0,0 +1,127 @@
+import { jsonSchemaToZod } from "json-schema-to-zod";
+
+//#region src/commands/pull-v3/components/artifact-component-generator.ts
+/**
+* Artifact Component Generator - Generate artifact component definitions
+*
+* Generates artifact components using the artifactComponent() builder function from @inkeep/agents-sdk
+* Handles isPreview flag with preview() function wrapper from @inkeep/agents-core
+*/
+const DEFAULT_STYLE = {
+	quotes: "single",
+	semicolons: true,
+	indentation: "  "
+};
+/**
+* Utility functions
+*/
+function toCamelCase(str) {
+	return str.toLowerCase().replace(/[-_](.)/g, (_, char) => char.toUpperCase()).replace(/[^a-zA-Z0-9]/g, "").replace(/^[0-9]/, "_$&");
+}
+function formatString(str, quote = "'", multiline = false) {
+	if (!str) return `${quote}${quote}`;
+	if (multiline && (str.includes("\n") || str.length > 80)) return `\`${str.replace(/`/g, "\\`")}\``;
+	return `${quote}${str.replace(new RegExp(quote, "g"), "\\" + quote)}${quote}`;
+}
+/**
+* Check if schema has any properties with inPreview: true
+*/
+function hasInPreviewFields(schema) {
+	if (!schema || typeof schema !== "object" || schema.type !== "object" || !schema.properties) return false;
+	for (const prop of Object.values(schema.properties)) if (prop.inPreview === true) return true;
+	return false;
+}
+/**
+* Format artifact schema with preview() wrappers based on inPreview: true in properties
+*/
+function formatArtifactSchema(schema, style) {
+	if (!schema || typeof schema !== "object") return "z.any()";
+	if (schema.type === "object" && schema.properties) {
+		const { indentation } = style;
+		const lines = ["z.object({"];
+		for (const [key, prop] of Object.entries(schema.properties)) {
+			const propCopy = { ...prop };
+			delete propCopy.inPreview;
+			const baseZodType = convertJsonSchemaToZod(propCopy);
+			const finalZodType = prop.inPreview === true ? `preview(${baseZodType})` : baseZodType;
+			lines.push(`${indentation}${key}: ${finalZodType},`);
+		}
+		lines.push("})");
+		if (schema.description) return lines.join("\n") + `.describe(\`${schema.description}\`)`;
+		return lines.join("\n");
+	}
+	return convertJsonSchemaToZod(schema);
+}
+/**
+* Convert JSON Schema to Zod schema using existing utility
+*/
+function convertJsonSchemaToZod(schema) {
+	if (!schema || typeof schema !== "object") return "z.any()";
+	try {
+		return jsonSchemaToZod(schema);
+	} catch (error) {
+		console.warn("Failed to convert JSON schema to Zod:", error);
+		return "z.any()";
+	}
+}
+/**
+* Generate Artifact Component Definition using artifactComponent() builder function
+*/
+function generateArtifactComponentDefinition(componentId, componentData, style = DEFAULT_STYLE) {
+	if (!componentId || typeof componentId !== "string") throw new Error("componentId is required and must be a string");
+	if (!componentData || typeof componentData !== "object") throw new Error(`componentData is required for artifact component '${componentId}'`);
+	const missingFields = ["name"].filter((field) => !componentData[field] || componentData[field] === null || componentData[field] === void 0);
+	if (!componentData.props) missingFields.push("props");
+	if (missingFields.length > 0) throw new Error(`Missing required fields for artifact component '${componentId}': ${missingFields.join(", ")}`);
+	const { quotes, semicolons, indentation } = style;
+	const q = quotes === "single" ? "'" : "\"";
+	const semi = semicolons ? ";" : "";
+	const componentVarName = toCamelCase(componentId);
+	const lines = [];
+	lines.push(`export const ${componentVarName} = artifactComponent({`);
+	lines.push(`${indentation}id: ${formatString(componentId, q)},`);
+	lines.push(`${indentation}name: ${formatString(componentData.name, q)},`);
+	lines.push(`${indentation}description: ${formatString(componentData.description, q, true)},`);
+	const schema = componentData.props || componentData.schema;
+	if (schema) {
+		const zodSchema = formatArtifactSchema(schema, style);
+		if (zodSchema.includes("\n")) {
+			const schemaLines = zodSchema.split("\n");
+			lines.push(`${indentation}props: ${schemaLines[0]}`);
+			schemaLines.slice(1, -1).forEach((line) => {
+				lines[lines.length - 1] += "\n" + indentation + line;
+			});
+			lines[lines.length - 1] += "\n" + indentation + schemaLines[schemaLines.length - 1] + ",";
+		} else lines.push(`${indentation}props: ${zodSchema},`);
+	}
+	if (componentData.template) lines.push(`${indentation}template: ${formatString(componentData.template, q, true)},`);
+	if (componentData.contentType) lines.push(`${indentation}contentType: ${formatString(componentData.contentType, q)},`);
+	if (lines.length > 0 && lines[lines.length - 1].endsWith(",")) lines[lines.length - 1] = lines[lines.length - 1].slice(0, -1);
+	lines.push(`})${semi}`);
+	return lines.join("\n");
+}
+/**
+* Generate imports needed for an artifact component file
+*/
+function generateArtifactComponentImports(componentId, componentData, style = DEFAULT_STYLE) {
+	const { quotes, semicolons } = style;
+	const q = quotes === "single" ? "'" : "\"";
+	const semi = semicolons ? ";" : "";
+	const imports = [];
+	const schema = componentData.props || componentData.schema;
+	if (hasInPreviewFields(schema)) imports.push(`import { preview } from ${q}@inkeep/agents-core${q}${semi}`);
+	imports.push(`import { artifactComponent } from ${q}@inkeep/agents-sdk${q}${semi}`);
+	if (schema) imports.push(`import { z } from ${q}zod${q}${semi}`);
+	return imports;
+}
+/**
+* Generate complete artifact component file (imports + definition)
+*/
+function generateArtifactComponentFile(componentId, componentData, style = DEFAULT_STYLE) {
+	const imports = generateArtifactComponentImports(componentId, componentData, style);
+	const definition = generateArtifactComponentDefinition(componentId, componentData, style);
+	return imports.join("\n") + "\n\n" + definition + "\n";
+}
+
+//#endregion
+export { generateArtifactComponentDefinition, generateArtifactComponentFile, generateArtifactComponentImports };

package/dist/commands/pull-v3/components/context-config-generator.js

@@ -0,0 +1,190 @@
+import { DEFAULT_STYLE, formatString, generateFileContent, generateImport, hasTemplateVariables, removeTrailingComma, toCamelCase } from "../utils/generator-utils.js";
+import { jsonSchemaToZod } from "json-schema-to-zod";
+
+//#region src/commands/pull-v3/components/context-config-generator.ts
+/**
+* Context Config Generator - Generate contextConfig definitions
+*
+* Generates contextConfig using contextConfig(), headers(), and fetchDefinition()
+* builder functions from @inkeep/agents-core
+*/
+/**
+* Process template variables in fetchConfig objects
+*/
+function processFetchConfigTemplates(fetchConfig, headersVarName) {
+	const processValue = (value) => {
+		if (typeof value === "string") {
+			if (hasTemplateVariables(value)) return `\`${value.replace(/\{\{headers\.([^}]+)\}\}/g, `\${${headersVarName}.toTemplate("$1")}`).replace(/`/g, "\\`")}\``;
+			if (value.includes("\n") || value.length > 80) return `\`${value.replace(/`/g, "\\`")}\``;
+			return `'${value.replace(/'/g, "\\'")}'`;
+		}
+		if (typeof value === "object" && value !== null) return processObject(value);
+		return JSON.stringify(value);
+	};
+	const processObject = (obj) => {
+		if (Array.isArray(obj)) return `[${obj.map((item) => processValue(item)).join(", ")}]`;
+		return `{\n    ${Object.entries(obj).filter(([key, val]) => val !== void 0 && val !== null).map(([key, val]) => {
+			return `${/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : `'${key}'`}: ${processValue(val)}`;
+		}).join(",\n    ")}\n  }`;
+	};
+	return processObject(fetchConfig);
+}
+/**
+* Generate Headers Definition using headers() builder function
+*/
+function generateHeadersDefinition(headersId, headersData, style = DEFAULT_STYLE) {
+	const { quotes, semicolons, indentation } = style;
+	const semi = semicolons ? ";" : "";
+	const headersVarName = toCamelCase(headersId);
+	const lines = [];
+	lines.push(`const ${headersVarName} = headers({`);
+	if (headersData.schema) {
+		const zodSchema = jsonSchemaToZod(headersData.schema, { module: "none" });
+		lines.push(`${indentation}schema: ${zodSchema},`);
+	}
+	removeTrailingComma(lines);
+	lines.push(`})${semi}`);
+	return lines.join("\n");
+}
+/**
+* Generate Fetch Definition using fetchDefinition() builder function
+*/
+function generateFetchDefinitionDefinition(fetchId, fetchData, style = DEFAULT_STYLE, headersVarName, registry) {
+	const { quotes, semicolons, indentation } = style;
+	const q = quotes === "single" ? "'" : "\"";
+	const semi = semicolons ? ";" : "";
+	const fetchVarName = toCamelCase(fetchId);
+	const lines = [];
+	lines.push(`const ${fetchVarName} = fetchDefinition({`);
+	lines.push(`${indentation}id: ${formatString(fetchData.id || fetchId, q)},`);
+	if (fetchData.name) lines.push(`${indentation}name: ${formatString(fetchData.name, q)},`);
+	if (fetchData.trigger) lines.push(`${indentation}trigger: ${formatString(fetchData.trigger, q)},`);
+	if (fetchData.fetchConfig) {
+		const processedFetchConfig = processFetchConfigTemplates(fetchData.fetchConfig, headersVarName || "headers");
+		lines.push(`${indentation}fetchConfig: ${processedFetchConfig},`);
+	}
+	if (fetchData.responseSchema) {
+		const zodSchema = jsonSchemaToZod(fetchData.responseSchema, { module: "none" });
+		lines.push(`${indentation}responseSchema: ${zodSchema},`);
+	}
+	if (fetchData.defaultValue) if (typeof fetchData.defaultValue === "string") {
+		const isMultiline = fetchData.defaultValue.includes("\n") || fetchData.defaultValue.length > 80;
+		lines.push(`${indentation}defaultValue: ${formatString(fetchData.defaultValue, q, isMultiline)},`);
+	} else lines.push(`${indentation}defaultValue: ${JSON.stringify(fetchData.defaultValue)},`);
+	if (fetchData.credentialReferenceId && registry) {
+		const validKey = registry.getVariableName(fetchData.credentialReferenceId, "credentials");
+		lines.push(`${indentation}credentialReference: ${validKey},`);
+	}
+	removeTrailingComma(lines);
+	lines.push(`})${semi}`);
+	return lines.join("\n");
+}
+/**
+* Generate Context Config Definition using contextConfig() builder function
+*/
+function generateContextConfigDefinition(contextId, contextData, style = DEFAULT_STYLE, registry, agentId, headersVarName) {
+	if (!contextId || typeof contextId !== "string") throw new Error("contextId is required and must be a string");
+	if (!contextData || typeof contextData !== "object") throw new Error(`contextData is required for context config '${contextId}'`);
+	const { quotes, semicolons, indentation } = style;
+	const q = quotes === "single" ? "'" : "\"";
+	const semi = semicolons ? ";" : "";
+	const contextVarName = (() => {
+		if (!registry) throw new Error("Registry is required for context config variable name generation");
+		const varName = registry.getVariableName(contextId, "contextConfigs");
+		if (!varName) throw new Error(`Failed to resolve variable name for context config: ${contextId}`);
+		return varName;
+	})();
+	const lines = [];
+	lines.push(`const ${contextVarName} = contextConfig({`);
+	if (contextData.id) lines.push(`${indentation}id: ${formatString(contextData.id, q)},`);
+	if (headersVarName) lines.push(`${indentation}headers: ${headersVarName},`);
+	else if (contextData.headers) lines.push(`${indentation}headers: ${contextData.headers},`);
+	if (contextData.contextVariables) {
+		const contextVarLines = [`${indentation}contextVariables: {`];
+		for (const [varName, varData] of Object.entries(contextData.contextVariables)) if (typeof varData === "string") contextVarLines.push(`${indentation}  ${varName}: ${varData},`);
+		else if (varData && typeof varData === "object" && (varData.fetchConfig || varData.responseSchema)) contextVarLines.push(`${indentation}  ${varName},`);
+		if (contextVarLines[contextVarLines.length - 1].endsWith(",")) contextVarLines[contextVarLines.length - 1] = contextVarLines[contextVarLines.length - 1].slice(0, -1);
+		contextVarLines.push(`${indentation}},`);
+		lines.push(...contextVarLines);
+	}
+	removeTrailingComma(lines);
+	lines.push(`})${semi}`);
+	return lines.join("\n");
+}
+/**
+* Generate imports needed for a context config file
+*/
+function generateContextConfigImports(contextId, contextData, style = DEFAULT_STYLE, registry) {
+	const imports = [];
+	const coreImports = [];
+	if (contextData.headers || hasHeadersInData(contextData)) coreImports.push("headers");
+	if (contextData.contextVariables && hasFetchDefinitionsInData(contextData)) coreImports.push("fetchDefinition");
+	coreImports.push("contextConfig");
+	if (coreImports.length > 0) imports.push(generateImport(coreImports, "@inkeep/agents-core", style));
+	if (hasSchemas(contextData)) imports.push(generateImport(["z"], "zod", style));
+	if (registry && contextData.contextVariables) {
+		const credentialRefs = [];
+		for (const [varName, varData] of Object.entries(contextData.contextVariables)) if (varData && typeof varData === "object" && varData.credentialReferenceId) credentialRefs.push({
+			id: varData.credentialReferenceId,
+			type: "credentials"
+		});
+		if (credentialRefs.length > 0) {
+			const contextComponent = registry.get(contextId, "contextConfigs");
+			if (contextComponent) {
+				const credentialImports = registry.getImportsForFile(contextComponent.filePath, credentialRefs);
+				imports.push(...credentialImports);
+			}
+		}
+	}
+	return imports;
+}
+/**
+* Helper functions to detect what imports are needed
+*/
+function hasHeadersInData(contextData) {
+	return !!contextData.headers || JSON.stringify(contextData).includes("headers");
+}
+function hasFetchDefinitionsInData(contextData) {
+	return JSON.stringify(contextData).includes("fetchDefinition") || contextData.contextVariables && Object.values(contextData.contextVariables).some((v) => v && typeof v === "object" && (v.fetchConfig || v.responseSchema));
+}
+function hasSchemas(contextData) {
+	const dataStr = JSON.stringify(contextData).toLowerCase();
+	return dataStr.includes("schema") || dataStr.includes("responseschema");
+}
+/**
+* Generate complete context config file (imports + all definitions)
+*/
+function generateContextConfigFile(contextId, contextData, style = DEFAULT_STYLE, registry, agentId) {
+	const imports = generateContextConfigImports(contextId, contextData, style, registry);
+	const definitions = [];
+	let headersVarName;
+	if (contextData.headersSchema) {
+		if (typeof contextData.headers === "string") headersVarName = contextData.headers;
+		else headersVarName = `${toCamelCase(contextId)}Headers`;
+		const headersDefinition = generateHeadersDefinition(headersVarName || "headers", { schema: contextData.headersSchema }, style);
+		definitions.push(headersDefinition);
+	}
+	if (contextData.contextVariables) {
+		for (const [varName, varData] of Object.entries(contextData.contextVariables)) if (varData && typeof varData === "object" && (varData.fetchConfig || varData.responseSchema)) {
+			const fetchDefinition = generateFetchDefinitionDefinition(varName, varData, style, headersVarName, registry);
+			definitions.push(fetchDefinition);
+		}
+	}
+	const contextDefinition = generateContextConfigDefinition(contextId, contextData, style, registry, agentId, headersVarName);
+	definitions.push(contextDefinition);
+	const exports = [(() => {
+		if (!registry) throw new Error("Registry is required for context config variable name generation");
+		const varName = registry.getVariableName(contextId, "contextConfigs");
+		if (!varName) throw new Error(`Failed to resolve variable name for context config: ${contextId}`);
+		return varName;
+	})()];
+	if (headersVarName) exports.push(headersVarName);
+	if (contextData.contextVariables) {
+		for (const [varName, varData] of Object.entries(contextData.contextVariables)) if (varData && typeof varData === "object" && (varData.fetchConfig || varData.responseSchema)) exports.push(varName);
+	}
+	definitions.push(`export { ${exports.join(", ")} };`);
+	return generateFileContent(imports, definitions);
+}
+
+//#endregion
+export { generateContextConfigDefinition, generateContextConfigFile, generateContextConfigImports, generateFetchDefinitionDefinition, generateHeadersDefinition };

package/dist/commands/pull-v3/components/credential-generator.js

@@ -0,0 +1,89 @@
+//#region src/commands/pull-v3/components/credential-generator.ts
+const DEFAULT_STYLE = {
+	quotes: "single",
+	semicolons: true,
+	indentation: "  "
+};
+/**
+* Utility functions
+*/
+function toCamelCase(str) {
+	return str.toLowerCase().replace(/[-_](.)/g, (_, char) => char.toUpperCase()).replace(/[^a-zA-Z0-9]/g, "").replace(/^[0-9]/, "_$&");
+}
+function formatString(str, quote = "'", multiline = false) {
+	if (!str) return `${quote}${quote}`;
+	if (multiline && (str.includes("\n") || str.length > 80)) return `\`${str.replace(/`/g, "\\`")}\``;
+	return `${quote}${str.replace(new RegExp(quote, "g"), "\\" + quote)}${quote}`;
+}
+/**
+* Format retrieval params object
+*/
+function formatRetrievalParams(retrievalParams, style, indentLevel) {
+	if (!retrievalParams || typeof retrievalParams !== "object") return "{}";
+	const { quotes, indentation } = style;
+	const q = quotes === "single" ? "'" : "\"";
+	const baseIndent = indentation.repeat(indentLevel);
+	const indent = indentation.repeat(indentLevel + 1);
+	const lines = ["{"];
+	for (const [key, value] of Object.entries(retrievalParams)) {
+		const formattedKey = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : `${q}${key}${q}`;
+		if (typeof value === "string") lines.push(`${indent}${formattedKey}: ${formatString(value, q)},`);
+		else if (typeof value === "number" || typeof value === "boolean") lines.push(`${indent}${formattedKey}: ${JSON.stringify(value)},`);
+		else if (typeof value === "object" && value !== null) lines.push(`${indent}${formattedKey}: ${formatRetrievalParams(value, style, indentLevel + 1)},`);
+	}
+	if (lines.length > 1 && lines[lines.length - 1].endsWith(",")) lines[lines.length - 1] = lines[lines.length - 1].slice(0, -1);
+	lines.push(`${baseIndent}}`);
+	return lines.join("\n");
+}
+/**
+* Generate Credential Definition using credential() builder function
+*/
+function generateCredentialDefinition(credentialId, credentialData, style = DEFAULT_STYLE) {
+	const { quotes, semicolons, indentation } = style;
+	const q = quotes === "single" ? "'" : "\"";
+	const semi = semicolons ? ";" : "";
+	const credentialVarName = toCamelCase(credentialId);
+	const lines = [];
+	lines.push(`export const ${credentialVarName} = credential({`);
+	lines.push(`${indentation}id: ${formatString(credentialId, q)},`);
+	const missingFields = [
+		"name",
+		"type",
+		"credentialStoreId"
+	].filter((field) => !credentialData[field] || credentialData[field] === null || credentialData[field] === void 0);
+	if (missingFields.length > 0) throw new Error(`Missing required fields for credential '${credentialId}': ${missingFields.join(", ")}`);
+	lines.push(`${indentation}name: ${formatString(credentialData.name, q)},`);
+	lines.push(`${indentation}type: ${formatString(credentialData.type, q)},`);
+	lines.push(`${indentation}credentialStoreId: ${formatString(credentialData.credentialStoreId, q)},`);
+	if (credentialData.description) lines.push(`${indentation}description: ${formatString(credentialData.description, q, true)},`);
+	if (credentialData.retrievalParams) {
+		const formattedParams = formatRetrievalParams(credentialData.retrievalParams, style, 1);
+		if (formattedParams.includes("\n")) lines.push(`${indentation}retrievalParams: ${formattedParams},`);
+		else lines.push(`${indentation}retrievalParams: ${formattedParams},`);
+	}
+	if (lines.length > 0 && lines[lines.length - 1].endsWith(",")) lines[lines.length - 1] = lines[lines.length - 1].slice(0, -1);
+	lines.push(`})${semi}`);
+	return lines.join("\n");
+}
+/**
+* Generate imports needed for a credential file
+*/
+function generateCredentialImports(credentialId, credentialData, style = DEFAULT_STYLE) {
+	const { quotes, semicolons } = style;
+	const q = quotes === "single" ? "'" : "\"";
+	const semi = semicolons ? ";" : "";
+	const imports = [];
+	imports.push(`import { credential } from ${q}@inkeep/agents-sdk${q}${semi}`);
+	return imports;
+}
+/**
+* Generate complete credential file (imports + definition)
+*/
+function generateCredentialFile(credentialId, credentialData, style = DEFAULT_STYLE) {
+	const imports = generateCredentialImports(credentialId, credentialData, style);
+	const definition = generateCredentialDefinition(credentialId, credentialData, style);
+	return imports.join("\n") + "\n\n" + definition + "\n";
+}
+
+//#endregion
+export { generateCredentialDefinition, generateCredentialFile, generateCredentialImports };