@inkeep/agents-cli 0.39.5 → 0.41.0

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

@@ -0,0 +1,145 @@
+import { DEFAULT_STYLE, formatObject, formatString, generateFileContent, generateImport, removeTrailingComma, shouldInclude, toCamelCase } from "../utils/generator-utils.js";
+
+//#region src/commands/pull-v3/components/project-generator.ts
+/**
+* Generate Project Definition using project() builder function
+*/
+function generateProjectDefinition(projectId, projectData, style = DEFAULT_STYLE, registry) {
+	if (!projectId || typeof projectId !== "string") throw new Error("projectId is required and must be a string");
+	if (!projectData || typeof projectData !== "object") throw new Error(`projectData is required for project '${projectId}'`);
+	const missingFields = ["name", "models"].filter((field) => !projectData[field] || projectData[field] === null || projectData[field] === void 0);
+	if (!projectData.models?.base) missingFields.push("models.base");
+	if (missingFields.length > 0) throw new Error(`Missing required fields for project '${projectId}': ${missingFields.join(", ")}`);
+	const { quotes, semicolons, indentation } = style;
+	const q = quotes === "single" ? "'" : "\"";
+	const semi = semicolons ? ";" : "";
+	const projectVarName = toCamelCase(projectId);
+	const lines = [];
+	lines.push(`export const ${projectVarName} = project({`);
+	lines.push(`${indentation}id: ${formatString(projectId, q)},`);
+	lines.push(`${indentation}name: ${formatString(projectData.name, q)},`);
+	if (shouldInclude(projectData.description)) lines.push(`${indentation}description: ${formatString(projectData.description, q, true)},`);
+	if (shouldInclude(projectData.models)) lines.push(`${indentation}models: ${formatObject(projectData.models, style, 2)},`);
+	if (shouldInclude(projectData.stopWhen)) {
+		lines.push(`${indentation}stopWhen: {`);
+		if (projectData.stopWhen.transferCountIs !== void 0) lines.push(`${indentation}${indentation}transferCountIs: ${projectData.stopWhen.transferCountIs}, // Max transfers for agents`);
+		if (projectData.stopWhen.stepCountIs !== void 0) lines.push(`${indentation}${indentation}stepCountIs: ${projectData.stopWhen.stepCountIs} // Max steps for sub-agents`);
+		if (lines.length > 1) {
+			const lastLine = lines[lines.length - 1];
+			if (lastLine.includes(",") && (lastLine.includes("//") || lastLine.endsWith(","))) if (lastLine.includes("//")) lines[lines.length - 1] = lastLine.replace(", //", " //");
+			else lines[lines.length - 1] = lastLine.slice(0, -1);
+		}
+		lines.push(`${indentation}},`);
+	}
+	if (shouldInclude(projectData.agents)) {
+		const agentsArray = registry ? registry.formatReferencesForCode(projectData.agents, "agents", style, 2) : "[]";
+		lines.push(`${indentation}agents: () => ${agentsArray},`);
+	}
+	if (shouldInclude(projectData.tools)) {
+		const toolsArray = registry ? registry.formatReferencesForCode(projectData.tools, "tools", style, 2) : "[]";
+		lines.push(`${indentation}tools: () => ${toolsArray},`);
+	}
+	if (shouldInclude(projectData.externalAgents)) {
+		const externalAgentsArray = registry ? registry.formatReferencesForCode(projectData.externalAgents, "externalAgents", style, 2) : "[]";
+		lines.push(`${indentation}externalAgents: () => ${externalAgentsArray},`);
+	}
+	if (shouldInclude(projectData.dataComponents)) {
+		const dataComponentsArray = registry ? registry.formatReferencesForCode(projectData.dataComponents, "dataComponents", style, 2) : "[]";
+		lines.push(`${indentation}dataComponents: () => ${dataComponentsArray},`);
+	}
+	if (shouldInclude(projectData.artifactComponents)) {
+		const artifactComponentsArray = registry ? registry.formatReferencesForCode(projectData.artifactComponents, "artifactComponents", style, 2) : "[]";
+		lines.push(`${indentation}artifactComponents: () => ${artifactComponentsArray},`);
+	}
+	if (shouldInclude(projectData.credentialReferences)) {
+		const credentialReferencesArray = registry ? registry.formatReferencesForCode(projectData.credentialReferences, "credentials", style, 2) : "[]";
+		lines.push(`${indentation}credentialReferences: () => ${credentialReferencesArray},`);
+	}
+	removeTrailingComma(lines);
+	lines.push(`})${semi}`);
+	return lines.join("\n");
+}
+/**
+* Generate imports needed for a project file
+*/
+function generateProjectImports(projectId, projectData, style = DEFAULT_STYLE, registry) {
+	const imports = [];
+	imports.push(generateImport(["project"], "@inkeep/agents-sdk", style));
+	if (registry) {
+		const currentFilePath = "index.ts";
+		const referencedComponents = [];
+		if (projectData.agents) {
+			let agentIds = [];
+			if (Array.isArray(projectData.agents)) agentIds = projectData.agents;
+			else if (typeof projectData.agents === "object") agentIds = Object.keys(projectData.agents);
+			for (const agentId of agentIds) referencedComponents.push({
+				id: agentId,
+				type: "agents"
+			});
+		}
+		if (projectData.tools) {
+			let toolIds = [];
+			if (Array.isArray(projectData.tools)) toolIds = projectData.tools;
+			else if (typeof projectData.tools === "object") toolIds = Object.keys(projectData.tools);
+			for (const toolId of toolIds) {
+				let componentType = "tools";
+				if (registry && registry.get(toolId, "functionTools")) componentType = "functionTools";
+				else if (registry && registry.get(toolId, "tools")) componentType = "tools";
+				referencedComponents.push({
+					id: toolId,
+					type: componentType
+				});
+			}
+		}
+		if (projectData.externalAgents) {
+			let extAgentIds = [];
+			if (Array.isArray(projectData.externalAgents)) extAgentIds = projectData.externalAgents;
+			else if (typeof projectData.externalAgents === "object") extAgentIds = Object.keys(projectData.externalAgents);
+			for (const extAgentId of extAgentIds) referencedComponents.push({
+				id: extAgentId,
+				type: "externalAgents"
+			});
+		}
+		if (projectData.dataComponents) {
+			let dataCompIds = [];
+			if (Array.isArray(projectData.dataComponents)) dataCompIds = projectData.dataComponents;
+			else if (typeof projectData.dataComponents === "object") dataCompIds = Object.keys(projectData.dataComponents);
+			for (const dataCompId of dataCompIds) referencedComponents.push({
+				id: dataCompId,
+				type: "dataComponents"
+			});
+		}
+		if (projectData.artifactComponents) {
+			let artifactCompIds = [];
+			if (Array.isArray(projectData.artifactComponents)) artifactCompIds = projectData.artifactComponents;
+			else if (typeof projectData.artifactComponents === "object") artifactCompIds = Object.keys(projectData.artifactComponents);
+			for (const artifactCompId of artifactCompIds) referencedComponents.push({
+				id: artifactCompId,
+				type: "artifactComponents"
+			});
+		}
+		if (projectData.credentialReferences) {
+			let credIds = [];
+			if (Array.isArray(projectData.credentialReferences)) credIds = projectData.credentialReferences;
+			else if (typeof projectData.credentialReferences === "object") credIds = Object.keys(projectData.credentialReferences);
+			for (const credId of credIds) referencedComponents.push({
+				id: credId,
+				type: "credentials"
+			});
+		}
+		if (referencedComponents.length > 0) {
+			const componentImports = registry.getImportsForFile(currentFilePath, referencedComponents);
+			imports.push(...componentImports);
+		}
+	}
+	return imports;
+}
+/**
+* Generate complete project file (imports + definition)
+*/
+function generateProjectFile(projectId, projectData, style = DEFAULT_STYLE, registry) {
+	return generateFileContent(generateProjectImports(projectId, projectData, style, registry), [generateProjectDefinition(projectId, projectData, style, registry)]);
+}
+
+//#endregion
+export { generateProjectDefinition, generateProjectFile, generateProjectImports };

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

@@ -0,0 +1,92 @@
+import { jsonSchemaToZod } from "json-schema-to-zod";
+
+//#region src/commands/pull-v3/components/status-component-generator.ts
+/**
+* Status Component Generator - Generate status component definitions
+*
+* Generates status components using the statusComponent() builder function from @inkeep/agents-sdk
+* Status components are used for progress updates and event notifications in agents
+*/
+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}`;
+}
+/**
+* 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 Status Component Definition using statusComponent() builder function
+*/
+function generateStatusComponentDefinition(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 status component '${componentId}'`);
+	const missingFields = ["type"].filter((field) => !componentData[field] || componentData[field] === null || componentData[field] === void 0);
+	if (missingFields.length > 0) throw new Error(`Missing required fields for status 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} = statusComponent({`);
+	lines.push(`${indentation}type: ${formatString(componentData.type, q)},`);
+	if (componentData.description) lines.push(`${indentation}description: ${formatString(componentData.description, q, true)},`);
+	const schema = componentData.detailsSchema || componentData.schema;
+	if (schema) {
+		const zodSchema = convertJsonSchemaToZod(schema);
+		if (zodSchema.includes("\n")) {
+			const schemaLines = zodSchema.split("\n");
+			lines.push(`${indentation}detailsSchema: ${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}detailsSchema: ${zodSchema},`);
+	}
+	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 status component file
+*/
+function generateStatusComponentImports(componentId, componentData, style = DEFAULT_STYLE) {
+	const { quotes, semicolons } = style;
+	const q = quotes === "single" ? "'" : "\"";
+	const semi = semicolons ? ";" : "";
+	const imports = [];
+	imports.push(`import { statusComponent } from ${q}@inkeep/agents-sdk${q}${semi}`);
+	if (componentData.detailsSchema || componentData.schema) imports.push(`import { z } from ${q}zod${q}${semi}`);
+	return imports;
+}
+/**
+* Generate complete status component file (imports + definition)
+*/
+function generateStatusComponentFile(componentId, componentData, style = DEFAULT_STYLE) {
+	const imports = generateStatusComponentImports(componentId, componentData, style);
+	const definition = generateStatusComponentDefinition(componentId, componentData, style);
+	return imports.join("\n") + "\n\n" + definition + "\n";
+}
+
+//#endregion
+export { generateStatusComponentDefinition, generateStatusComponentFile, generateStatusComponentImports };

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

@@ -0,0 +1,285 @@
+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/sub-agent-generator.ts
+/**
+* Sub Agent Generator - Generate sub-agent definitions
+*
+* Generates sub-agents using the subAgent() builder function from @inkeep/agents-sdk
+* Sub-agents are the individual agents within an agent graph that handle specific tasks
+*/
+/**
+* Check if subAgent models are different from parent agent models (or project models)
+*/
+function hasDistinctModels(subAgentModels, parentModels) {
+	if (!subAgentModels) return false;
+	if (!parentModels) return !!subAgentModels;
+	for (const type of [
+		"base",
+		"structuredOutput",
+		"summarizer"
+	]) {
+		const subAgentModel = subAgentModels[type]?.model;
+		const parentModel = parentModels[type]?.model;
+		if (subAgentModel !== parentModel) return true;
+		if (subAgentModel && parentModel) {
+			const subAgentOptions = subAgentModels[type]?.providerOptions;
+			const parentOptions = parentModels[type]?.providerOptions;
+			if (subAgentOptions !== parentOptions) {
+				if (!subAgentOptions && !parentOptions) continue;
+				if (!subAgentOptions || !parentOptions) return true;
+				if (!compareJsonObjects(subAgentOptions, parentOptions, {
+					ignoreArrayOrder: true,
+					showDetails: false
+				}).isEqual) return true;
+			}
+		}
+	}
+	return false;
+}
+/**
+* Generate Sub Agent Definition using subAgent() builder function
+*/
+function generateSubAgentDefinition(agentId, agentData, style = DEFAULT_STYLE, registry, parentAgentId, contextConfigData, parentModels) {
+	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 sub-agent '${agentId}'`);
+	const { quotes, semicolons, indentation } = style;
+	const q = quotes === "single" ? "'" : "\"";
+	const semi = semicolons ? ";" : "";
+	let agentVarName = toCamelCase(agentId);
+	if (registry) {
+		const registryVarName = registry.getVariableName(agentId, "subAgents");
+		if (registryVarName) agentVarName = registryVarName;
+	}
+	const agentName = agentData.name !== void 0 && agentData.name !== null ? agentData.name : agentId.replace(/[-_]/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").replace(/\b\w/g, (c) => c.toUpperCase());
+	const lines = [];
+	lines.push(`export const ${agentVarName} = subAgent({`);
+	lines.push(`${indentation}id: ${formatString(agentId, q)},`);
+	lines.push(`${indentation}name: ${formatString(agentName, q)},`);
+	lines.push(`${indentation}description: ${formatString(agentData.description, q, true)},`);
+	if (agentData.prompt !== void 0 && agentData.prompt !== null) if (hasTemplateVariables(agentData.prompt) && parentAgentId && registry && contextConfigData) {
+		const contextVarName = registry.getVariableName(contextConfigData.id, "contextConfigs");
+		if (!contextVarName) throw new Error(`Failed to resolve context config variable name for: ${contextConfigData.id}`);
+		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, parentModels)) {
+		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.canUse && Array.isArray(agentData.canUse) && agentData.canUse.length > 0) {
+		const toolReferences = [];
+		if (!registry) throw new Error("Registry is required for canUse generation");
+		for (const toolRelation of agentData.canUse) {
+			const toolId = toolRelation.toolId;
+			let toolVarName = registry.getVariableName(toolId, "tools");
+			if (!toolVarName) toolVarName = registry.getVariableName(toolId, "functionTools");
+			if (!toolVarName) throw new Error(`Failed to resolve variable name for tool: ${toolId} (tried both 'tools' and 'functionTools' types)`);
+			const hasToolSelection = toolRelation.toolSelection && toolRelation.toolSelection.length > 0;
+			const hasHeaders = toolRelation.headers && Object.keys(toolRelation.headers).length > 0;
+			if (hasToolSelection || hasHeaders) {
+				const configLines = [];
+				if (hasToolSelection) {
+					const selectedToolsStr = JSON.stringify(toolRelation.toolSelection);
+					configLines.push(`selectedTools: ${selectedToolsStr}`);
+				}
+				if (hasHeaders) {
+					const headersStr = JSON.stringify(toolRelation.headers);
+					configLines.push(`headers: ${headersStr}`);
+				}
+				const configStr = configLines.join(", ");
+				const finalRef = `${toolVarName}.with({ ${configStr} })`;
+				toolReferences.push(finalRef);
+			} else toolReferences.push(toolVarName);
+		}
+		const { indentation: indent } = style;
+		const nestedIndent = indent.repeat(2);
+		if (toolReferences.length === 1) lines.push(`${indentation}canUse: () => [${toolReferences[0]}],`);
+		else {
+			lines.push(`${indentation}canUse: () => [`);
+			toolReferences.forEach((ref, index) => {
+				const isLast = index === toolReferences.length - 1;
+				lines.push(`${indentation}${nestedIndent}${ref}${isLast ? "" : ","}`);
+			});
+			lines.push(`${indentation}],`);
+		}
+	}
+	if (agentData.canDelegateTo && Array.isArray(agentData.canDelegateTo) && agentData.canDelegateTo.length > 0) {
+		if (!registry) throw new Error("Registry is required for canDelegateTo generation");
+		const delegateReferences = [];
+		for (const delegateRelation of agentData.canDelegateTo) {
+			let targetAgentId;
+			let targetType;
+			let hasHeaders = false;
+			if (typeof delegateRelation === "string") {
+				targetAgentId = delegateRelation;
+				targetType = "subAgents";
+				hasHeaders = false;
+			} else if (delegateRelation && typeof delegateRelation === "object") {
+				hasHeaders = delegateRelation.headers && Object.keys(delegateRelation.headers).length > 0;
+				if (delegateRelation.externalAgentId) {
+					targetAgentId = delegateRelation.externalAgentId;
+					targetType = "externalAgents";
+				} else if (delegateRelation.agentId) {
+					targetAgentId = delegateRelation.agentId;
+					targetType = "agents";
+				} else if (delegateRelation.subAgentId) {
+					targetAgentId = delegateRelation.subAgentId;
+					targetType = "subAgents";
+				} else throw new Error(`Delegate relation missing agentId, subAgentId, or externalAgentId: ${JSON.stringify(delegateRelation)}`);
+			} else throw new Error(`Invalid delegate relation format: ${JSON.stringify(delegateRelation)}`);
+			if (!targetAgentId) throw new Error(`Failed to extract target agent ID from delegate relation: ${JSON.stringify(delegateRelation)}`);
+			const agentVarName$1 = registry.getVariableName(targetAgentId, targetType);
+			if (!agentVarName$1) throw new Error(`Failed to resolve variable name for delegate ${targetType}: ${targetAgentId}`);
+			if (hasHeaders) {
+				const finalRef = `${agentVarName$1}.with({ headers: ${JSON.stringify(delegateRelation.headers)} })`;
+				delegateReferences.push(finalRef);
+			} else delegateReferences.push(agentVarName$1);
+		}
+		const { indentation: indent } = style;
+		const nestedIndent = indent.repeat(2);
+		if (delegateReferences.length === 1) lines.push(`${indentation}canDelegateTo: () => [${delegateReferences[0]}],`);
+		else {
+			lines.push(`${indentation}canDelegateTo: () => [`);
+			delegateReferences.forEach((ref, index) => {
+				const isLast = index === delegateReferences.length - 1;
+				lines.push(`${indentation}${nestedIndent}${ref}${isLast ? "" : ","}`);
+			});
+			lines.push(`${indentation}],`);
+		}
+	}
+	if (agentData.canTransferTo && Array.isArray(agentData.canTransferTo) && agentData.canTransferTo.length > 0) {
+		if (!registry) throw new Error("Registry is required for canTransferTo generation");
+		const transferArray = registry.formatReferencesForCode(agentData.canTransferTo, "subAgents", style, 2);
+		if (!transferArray) throw new Error(`Failed to resolve variable names for canTransferTo agents: ${agentData.canTransferTo.join(", ")}`);
+		lines.push(`${indentation}canTransferTo: () => ${transferArray},`);
+	}
+	if (agentData.dataComponents && Array.isArray(agentData.dataComponents) && agentData.dataComponents.length > 0) {
+		if (!registry) throw new Error("Registry is required for dataComponents generation");
+		const dataComponentsArray = registry.formatReferencesForCode(agentData.dataComponents, "dataComponents", style, 2);
+		if (!dataComponentsArray) throw new Error(`Failed to resolve variable names for data components: ${agentData.dataComponents.join(", ")}`);
+		lines.push(`${indentation}dataComponents: () => ${dataComponentsArray},`);
+	}
+	if (agentData.artifactComponents && Array.isArray(agentData.artifactComponents) && agentData.artifactComponents.length > 0) {
+		if (!registry) throw new Error("Registry is required for artifactComponents generation");
+		const artifactComponentsArray = registry.formatReferencesForCode(agentData.artifactComponents, "artifactComponents", style, 2);
+		if (!artifactComponentsArray) throw new Error(`Failed to resolve variable names for artifact components: ${agentData.artifactComponents.join(", ")}`);
+		lines.push(`${indentation}artifactComponents: () => ${artifactComponentsArray},`);
+	}
+	if (agentData.stopWhen && agentData.stopWhen.stepCountIs !== void 0) {
+		lines.push(`${indentation}stopWhen: {`);
+		lines.push(`${indentation}${indentation}stepCountIs: ${agentData.stopWhen.stepCountIs} // Max tool calls + LLM responses`);
+		lines.push(`${indentation}},`);
+	}
+	removeTrailingComma(lines);
+	lines.push(`})${semi}`);
+	return lines.join("\n");
+}
+/**
+* Generate imports needed for a sub-agent file
+*/
+function generateSubAgentImports(agentId, agentData, style = DEFAULT_STYLE, registry, parentAgentId, contextConfigData, actualFilePath) {
+	const imports = [];
+	imports.push(generateImport(["subAgent"], "@inkeep/agents-sdk", style));
+	if (hasTemplateVariables(agentData.prompt) && parentAgentId && registry && contextConfigData) {
+		const contextConfigId = contextConfigData.id;
+		const currentFilePath = actualFilePath || `agents/sub-agents/${agentId}.ts`;
+		const importStatement = registry.getImportStatement(currentFilePath, contextConfigId, "contextConfigs");
+		if (importStatement) imports.push(importStatement);
+	}
+	if (registry) {
+		const currentFilePath = actualFilePath || `agents/sub-agents/${agentId}.ts`;
+		const referencedComponents = [];
+		if (Array.isArray(agentData.canUse)) for (const toolRelation of agentData.canUse) {
+			const toolId = toolRelation.toolId;
+			if (toolId) {
+				let componentType = "tools";
+				if (registry.get(toolId, "functionTools")) componentType = "functionTools";
+				else if (registry.get(toolId, "tools")) componentType = "tools";
+				referencedComponents.push({
+					id: toolId,
+					type: componentType
+				});
+			}
+		}
+		if (Array.isArray(agentData.canDelegateTo)) for (const delegateRelation of agentData.canDelegateTo) {
+			let targetId;
+			let targetType = "agents";
+			if (delegateRelation && typeof delegateRelation === "object") {
+				if (delegateRelation.externalAgentId) {
+					targetId = delegateRelation.externalAgentId;
+					targetType = "externalAgents";
+				} else if (delegateRelation.agentId) {
+					targetId = delegateRelation.agentId;
+					targetType = "agents";
+				} else if (delegateRelation.subAgentId) {
+					targetId = delegateRelation.subAgentId;
+					targetType = "subAgents";
+				}
+			}
+			if (targetId) referencedComponents.push({
+				id: targetId,
+				type: targetType
+			});
+		}
+		if (Array.isArray(agentData.canTransferTo)) {
+			for (const transferId of agentData.canTransferTo) if (typeof transferId === "string") referencedComponents.push({
+				id: transferId,
+				type: "subAgents"
+			});
+		}
+		if (Array.isArray(agentData.dataComponents)) {
+			for (const dataCompId of agentData.dataComponents) if (typeof dataCompId === "string") referencedComponents.push({
+				id: dataCompId,
+				type: "dataComponents"
+			});
+		}
+		if (Array.isArray(agentData.artifactComponents)) {
+			for (const artifactCompId of agentData.artifactComponents) if (typeof artifactCompId === "string") referencedComponents.push({
+				id: artifactCompId,
+				type: "artifactComponents"
+			});
+		}
+		if (referencedComponents.length > 0) {
+			const componentImports = registry.getImportsForFile(currentFilePath, referencedComponents);
+			imports.push(...componentImports);
+		}
+	}
+	return imports;
+}
+/**
+* Generate complete sub-agent file (imports + definition)
+*/
+function generateSubAgentFile(agentId, agentData, style = DEFAULT_STYLE, registry, parentAgentId, contextConfigData, parentModels, actualFilePath) {
+	return generateFileContent(generateSubAgentImports(agentId, agentData, style, registry, parentAgentId, contextConfigData, actualFilePath), [generateSubAgentDefinition(agentId, agentData, style, registry, parentAgentId, contextConfigData, parentModels)]);
+}
+
+//#endregion
+export { generateSubAgentDefinition, generateSubAgentFile, generateSubAgentImports };