@inkeep/agents-cli 0.39.4 → 0.40.0

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

@@ -0,0 +1,102 @@
+import { jsonSchemaToZod } from "json-schema-to-zod";
+
+//#region src/commands/pull-v3/components/data-component-generator.ts
+/**
+* Data Component Generator - Generate data component definitions
+*
+* Generates data components using the dataComponent() builder function from @inkeep/agents-sdk
+*/
+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 Data Component Definition using dataComponent() builder function
+*/
+function generateDataComponentDefinition(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 data 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 data 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} = dataComponent({`);
+	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 = convertJsonSchemaToZod(schema);
+		lines.push(`${indentation}props: ${zodSchema},`);
+	}
+	if (componentData.render && typeof componentData.render === "object") {
+		const render = componentData.render;
+		if (render.component && typeof render.component === "string") {
+			lines.push(`${indentation}render: {`);
+			const componentString = JSON.stringify(render.component);
+			lines.push(`${indentation}${indentation}component: ${componentString},`);
+			if (render.mockData && typeof render.mockData === "object") {
+				const formattedMockData = JSON.stringify(render.mockData, null, 2).split("\n").map((line, index) => {
+					if (index === 0) return line;
+					return `${indentation}${indentation}${line}`;
+				}).join("\n");
+				lines.push(`${indentation}${indentation}mockData: ${formattedMockData},`);
+			}
+			lines.push(`${indentation}},`);
+		}
+	}
+	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 data component file
+*/
+function generateDataComponentImports(componentId, componentData, style = DEFAULT_STYLE) {
+	const { quotes, semicolons } = style;
+	const q = quotes === "single" ? "'" : "\"";
+	const semi = semicolons ? ";" : "";
+	const imports = [];
+	imports.push(`import { dataComponent } from ${q}@inkeep/agents-sdk${q}${semi}`);
+	if (componentData.props || componentData.schema) imports.push(`import { z } from ${q}zod${q}${semi}`);
+	return imports;
+}
+/**
+* Generate complete data component file (imports + definition)
+*/
+function generateDataComponentFile(componentId, componentData, style = DEFAULT_STYLE) {
+	const imports = generateDataComponentImports(componentId, componentData, style);
+	const definition = generateDataComponentDefinition(componentId, componentData, style);
+	return imports.join("\n") + "\n\n" + definition + "\n";
+}
+
+//#endregion
+export { generateDataComponentDefinition, generateDataComponentFile, generateDataComponentImports };

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

@@ -0,0 +1,170 @@
+//#region src/commands/pull-v3/components/environment-generator.ts
+const DEFAULT_STYLE = {
+	quotes: "single",
+	semicolons: true,
+	indentation: "  "
+};
+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 credentials object for environment settings
+*/
+function formatCredentialsObject(credentials, style, indentLevel) {
+	if (!credentials || typeof credentials !== "object") return "{}";
+	const { quotes, indentation } = style;
+	const q = quotes === "single" ? "'" : "\"";
+	const baseIndent = indentation.repeat(indentLevel);
+	const indent = indentation.repeat(indentLevel + 1);
+	const nestedIndent = indentation.repeat(indentLevel + 2);
+	const lines = ["{"];
+	for (const [key, credentialData] of Object.entries(credentials)) {
+		lines.push(`${indent}${formatString(key, q)}: {`);
+		if (credentialData.id) lines.push(`${nestedIndent}id: ${formatString(credentialData.id, q)},`);
+		if (credentialData.name) lines.push(`${nestedIndent}name: ${formatString(credentialData.name, q)},`);
+		if (credentialData.type) if (typeof credentialData.type === "string") {
+			const enumValue = credentialData.type === "memory" ? "CredentialStoreType.memory" : credentialData.type === "env" ? "CredentialStoreType.env" : credentialData.type === "keychain" ? "CredentialStoreType.keychain" : formatString(credentialData.type, q);
+			lines.push(`${nestedIndent}type: ${enumValue},`);
+		} else lines.push(`${nestedIndent}type: ${credentialData.type},`);
+		if (credentialData.credentialStoreId) lines.push(`${nestedIndent}credentialStoreId: ${formatString(credentialData.credentialStoreId, q)},`);
+		if (credentialData.description) lines.push(`${nestedIndent}description: ${formatString(credentialData.description, q)},`);
+		if (credentialData.retrievalParams) {
+			lines.push(`${nestedIndent}retrievalParams: {`);
+			for (const [paramKey, paramValue] of Object.entries(credentialData.retrievalParams)) {
+				if (paramValue === null || paramValue === void 0) continue;
+				if (typeof paramValue === "string") lines.push(`${nestedIndent}${indent}${paramKey}: ${formatString(paramValue, q)},`);
+				else lines.push(`${nestedIndent}${indent}${paramKey}: ${JSON.stringify(paramValue)},`);
+			}
+			const lastLineIndex = lines.length - 1;
+			if (lines[lastLineIndex].endsWith(",")) lines[lastLineIndex] = lines[lastLineIndex].slice(0, -1);
+			lines.push(`${nestedIndent}},`);
+		}
+		const lastPropIndex = lines.length - 1;
+		if (lines[lastPropIndex].endsWith(",")) lines[lastPropIndex] = lines[lastPropIndex].slice(0, -1);
+		lines.push(`${indent}},`);
+	}
+	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 Individual Environment Settings Definition (development.env.ts, production.env.ts)
+*/
+function generateEnvironmentSettingsDefinition(environmentName, environmentData, style = DEFAULT_STYLE) {
+	if (!environmentName || typeof environmentName !== "string") throw new Error("environmentName is required and must be a string");
+	if (!environmentData || typeof environmentData !== "object") throw new Error(`environmentData is required for environment '${environmentName}'`);
+	const { quotes, semicolons, indentation } = style;
+	const semi = semicolons ? ";" : "";
+	const lines = [];
+	lines.push(`export const ${environmentName} = registerEnvironmentSettings({`);
+	if (environmentData.credentials && Object.keys(environmentData.credentials).length > 0) {
+		const formattedCredentials = formatCredentialsObject(environmentData.credentials, style, 1);
+		lines.push(`${indentation}credentials: ${formattedCredentials},`);
+	} else lines.push(`${indentation}credentials: {},`);
+	if (lines.length > 1 && lines[lines.length - 1].endsWith(",")) lines[lines.length - 1] = lines[lines.length - 1].slice(0, -1);
+	lines.push(`})${semi}`);
+	return lines.join("\n");
+}
+/**
+* Generate Main Environment Settings Index (index.ts)
+*/
+function generateEnvironmentIndexDefinition(environments, style = DEFAULT_STYLE) {
+	const { quotes, semicolons, indentation } = style;
+	const semi = semicolons ? ";" : "";
+	const lines = [];
+	lines.push(`export const envSettings = createEnvironmentSettings({`);
+	for (const envName of environments) lines.push(`${indentation}${envName},`);
+	if (lines.length > 1 && 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 for individual environment settings file
+*/
+function generateEnvironmentSettingsImports(environmentName, environmentData, style = DEFAULT_STYLE) {
+	const { quotes, semicolons } = style;
+	const q = quotes === "single" ? "'" : "\"";
+	const semi = semicolons ? ";" : "";
+	const imports = [];
+	imports.push(`import { registerEnvironmentSettings } from ${q}@inkeep/agents-sdk${q}${semi}`);
+	if (environmentData.credentials && Object.values(environmentData.credentials).some((cred) => typeof cred.type === "string" && [
+		"memory",
+		"env",
+		"keychain"
+	].includes(cred.type))) imports.push(`import { CredentialStoreType } from ${q}@inkeep/agents-core${q}${semi}`);
+	return imports;
+}
+/**
+* Generate imports for main environment index file
+*/
+function generateEnvironmentIndexImports(environments, style = DEFAULT_STYLE) {
+	const { quotes, semicolons } = style;
+	const q = quotes === "single" ? "'" : "\"";
+	const semi = semicolons ? ";" : "";
+	const imports = [];
+	imports.push(`import { createEnvironmentSettings } from ${q}@inkeep/agents-sdk${q}${semi}`);
+	for (const envName of environments) imports.push(`import { ${envName} } from ${q}./${envName}.env${q}${semi}`);
+	return imports;
+}
+/**
+* Generate complete environment settings file
+*/
+function generateEnvironmentSettingsFile(environmentName, environmentData, style = DEFAULT_STYLE) {
+	const imports = generateEnvironmentSettingsImports(environmentName, environmentData, style);
+	const definition = generateEnvironmentSettingsDefinition(environmentName, environmentData, style);
+	return imports.join("\n") + "\n\n" + definition + "\n";
+}
+/**
+* Generate complete environment index file
+*/
+function generateEnvironmentIndexFile(environments, style = DEFAULT_STYLE) {
+	const imports = generateEnvironmentIndexImports(environments, style);
+	const definition = generateEnvironmentIndexDefinition(environments, style);
+	return imports.join("\n") + "\n\n" + definition + "\n";
+}
+/**
+* Generate environment file (alias for generateEnvironmentSettingsFile)
+* This is the main function used by introspect-generator
+*/
+function generateEnvironmentFile(environmentName, environmentData, style = DEFAULT_STYLE, registry) {
+	if (registry && environmentData.credentials && Array.isArray(environmentData.credentials)) {
+		const { quotes, semicolons, indentation } = style;
+		const q = quotes === "single" ? "'" : "\"";
+		const semi = semicolons ? ";" : "";
+		const imports = [];
+		const credentialRefs = [];
+		imports.push(`import { registerEnvironmentSettings } from ${q}@inkeep/agents-sdk${q}${semi}`);
+		for (const credentialId of environmentData.credentials) {
+			const credentialComponent = registry.get(credentialId, "credentials");
+			if (credentialComponent) {
+				const relativePath = `../credentials/${credentialId}`;
+				imports.push(`import { ${credentialComponent.name} } from ${q}${relativePath}${q}${semi}`);
+				credentialRefs.push(credentialComponent.name);
+			}
+		}
+		const lines = [];
+		lines.push(...imports);
+		lines.push("");
+		lines.push(`export const ${environmentName} = registerEnvironmentSettings({`);
+		if (credentialRefs.length > 0) {
+			lines.push(`${indentation}credentials: {`);
+			for (let i = 0; i < environmentData.credentials.length; i++) {
+				const credentialId = environmentData.credentials[i];
+				const credentialVarName = credentialRefs[i];
+				const isLast = i === credentialRefs.length - 1;
+				const validKey = registry.getVariableName(credentialId, "credentials");
+				lines.push(`${indentation}${indentation}${validKey}: ${credentialVarName}${isLast ? "" : ","}`);
+			}
+			lines.push(`${indentation}}`);
+		} else lines.push(`${indentation}credentials: {}`);
+		lines.push(`})${semi}`);
+		lines.push("");
+		return lines.join("\n");
+	}
+	return generateEnvironmentSettingsFile(environmentName, environmentData, style);
+}
+
+//#endregion
+export { generateEnvironmentFile, generateEnvironmentIndexDefinition, generateEnvironmentIndexFile, generateEnvironmentIndexImports, generateEnvironmentSettingsDefinition, generateEnvironmentSettingsFile, generateEnvironmentSettingsImports };

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

@@ -0,0 +1,75 @@
+import { DEFAULT_STYLE, formatString, generateFileContent, generateImport, removeTrailingComma, toCamelCase } from "../utils/generator-utils.js";
+
+//#region src/commands/pull-v3/components/external-agent-generator.ts
+/**
+* Generate External Agent Definition using externalAgent() builder function
+*/
+function generateExternalAgentDefinition(agentId, agentData, style = DEFAULT_STYLE, registry) {
+	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 external agent '${agentId}'`);
+	const missingFields = ["name", "baseUrl"].filter((field) => !agentData[field] || agentData[field] === null || agentData[field] === void 0);
+	if (missingFields.length > 0) throw new Error(`Missing required fields for external 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, "externalAgents");
+		if (registryVarName) agentVarName = registryVarName;
+	}
+	const lines = [];
+	lines.push(`export const ${agentVarName} = externalAgent({`);
+	lines.push(`${indentation}id: ${formatString(agentId, q)},`);
+	if (agentData.name !== void 0 && agentData.name !== null) lines.push(`${indentation}name: ${formatString(agentData.name, q)},`);
+	else lines.push(`${indentation}name: ${formatString(agentId, q)},`);
+	if (agentData.description !== void 0 && agentData.description !== null) lines.push(`${indentation}description: ${formatString(agentData.description, q, true)},`);
+	else lines.push(`${indentation}description: ${formatString(`External agent ${agentId}`, q)},`);
+	if (agentData.baseUrl !== void 0 && agentData.baseUrl !== null) lines.push(`${indentation}baseUrl: ${formatString(agentData.baseUrl, q)},`);
+	if (agentData.credentialReference) {
+		if (typeof agentData.credentialReference === "string") {
+			if (!registry) throw new Error("Registry is required for credentialReference generation");
+			const credentialVar = registry.getVariableName(agentData.credentialReference, "credentials");
+			if (!credentialVar) throw new Error(`Failed to resolve variable name for credential reference: ${agentData.credentialReference}`);
+			lines.push(`${indentation}credentialReference: ${credentialVar},`);
+		} else if (typeof agentData.credentialReference === "object") {
+			const credLines = [];
+			if (agentData.credentialReference.id) credLines.push(`${indentation}${indentation}id: ${formatString(agentData.credentialReference.id, q)},`);
+			if (agentData.credentialReference.name) credLines.push(`${indentation}${indentation}name: ${formatString(agentData.credentialReference.name, q)},`);
+			if (agentData.credentialReference.description) credLines.push(`${indentation}${indentation}description: ${formatString(agentData.credentialReference.description, q)},`);
+			if (credLines.length > 0 && credLines[credLines.length - 1].endsWith(",")) credLines[credLines.length - 1] = credLines[credLines.length - 1].slice(0, -1);
+			lines.push(`${indentation}credentialReference: {`);
+			lines.push(...credLines);
+			lines.push(`${indentation}},`);
+		}
+	}
+	removeTrailingComma(lines);
+	lines.push(`})${semi}`);
+	return lines.join("\n");
+}
+/**
+* Generate imports needed for an external agent file
+*/
+function generateExternalAgentImports(agentId, agentData, style = DEFAULT_STYLE, registry) {
+	const imports = [];
+	imports.push(generateImport(["externalAgent"], "@inkeep/agents-sdk", style));
+	if (agentData.credentialReference && typeof agentData.credentialReference === "string") {
+		if (!registry) throw new Error("Registry is required for credential reference imports");
+		const currentFilePath = `external-agents/${agentId}.ts`;
+		const credentialRefs = [{
+			id: agentData.credentialReference,
+			type: "credentials"
+		}];
+		const componentImports = registry.getImportsForFile(currentFilePath, credentialRefs);
+		imports.push(...componentImports);
+	}
+	return imports;
+}
+/**
+* Generate complete external agent file (imports + definition)
+*/
+function generateExternalAgentFile(agentId, agentData, style = DEFAULT_STYLE, registry) {
+	return generateFileContent(generateExternalAgentImports(agentId, agentData, style, registry), [generateExternalAgentDefinition(agentId, agentData, style, registry)]);
+}
+
+//#endregion
+export { generateExternalAgentDefinition, generateExternalAgentFile, generateExternalAgentImports };

package/dist/commands/pull-v3/components/function-tool-generator.js

@@ -0,0 +1,94 @@
+import { jsonSchemaToZod } from "json-schema-to-zod";
+
+//#region src/commands/pull-v3/components/function-tool-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 JavaScript function code with proper indentation
+*/
+function formatExecuteFunction(executeCode, indentation) {
+	if (!executeCode || typeof executeCode !== "string") return `async ({}) => {\n${indentation}  // TODO: Implement function logic\n${indentation}  return {};\n${indentation}}`;
+	const trimmedCode = executeCode.trim();
+	if (trimmedCode.includes("\n")) return trimmedCode.split("\n").map((line, index) => {
+		if (index === 0) return line;
+		return indentation + line;
+	}).join("\n");
+	if (trimmedCode.startsWith("async") || trimmedCode.startsWith("function")) return trimmedCode;
+	return `async ({}) => {\n${indentation}  ${executeCode.replace(/\n/g, `\n${indentation}  `)}\n${indentation}}`;
+}
+/**
+* Generate Function Tool Definition using functionTool() builder function
+*/
+function generateFunctionToolDefinition(toolId, toolData, style = DEFAULT_STYLE) {
+	if (!toolId || typeof toolId !== "string") throw new Error("toolId is required and must be a string");
+	if (!toolData || typeof toolData !== "object") throw new Error(`toolData is required for function tool '${toolId}'`);
+	const missingFields = ["name"].filter((field) => !toolData[field] || toolData[field] === null || toolData[field] === void 0);
+	if (!toolData.inputSchema && !toolData.schema) missingFields.push("inputSchema");
+	if (!toolData.executeCode && !toolData.execute) missingFields.push("executeCode");
+	if (missingFields.length > 0) throw new Error(`Missing required fields for function tool '${toolId}': ${missingFields.join(", ")}`);
+	const { quotes, semicolons, indentation } = style;
+	const q = quotes === "single" ? "'" : "\"";
+	const semi = semicolons ? ";" : "";
+	const toolVarName = toCamelCase(toolId);
+	const lines = [];
+	lines.push(`export const ${toolVarName} = functionTool({`);
+	lines.push(`${indentation}name: ${formatString(toolData.name, q)},`);
+	if (toolData.description) lines.push(`${indentation}description: ${formatString(toolData.description, q, true)},`);
+	const inputSchema = toolData.inputSchema || toolData.schema;
+	if (inputSchema) {
+		const formattedSchema = JSON.stringify(inputSchema, null, 2).split("\n").map((line, index) => {
+			if (index === 0) return `${indentation}inputSchema: ${line}`;
+			return `${indentation}${line}`;
+		}).join("\n");
+		lines.push(formattedSchema + ",");
+	}
+	const executeCode = toolData.executeCode || toolData.execute;
+	if (executeCode) {
+		const executeFunc = formatExecuteFunction(executeCode, indentation);
+		lines.push(`${indentation}execute: ${executeFunc},`);
+	} else {
+		lines.push(`${indentation}execute: async ({}) => {`);
+		lines.push(`${indentation}  // TODO: Implement function logic`);
+		lines.push(`${indentation}  return {};`);
+		lines.push(`${indentation}},`);
+	}
+	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 function tool file
+*/
+function generateFunctionToolImports(toolId, toolData, style = DEFAULT_STYLE) {
+	const { quotes, semicolons } = style;
+	const q = quotes === "single" ? "'" : "\"";
+	const semi = semicolons ? ";" : "";
+	const imports = [];
+	imports.push(`import { functionTool } from ${q}@inkeep/agents-sdk${q}${semi}`);
+	return imports;
+}
+/**
+* Generate complete function tool file (imports + definition)
+*/
+function generateFunctionToolFile(toolId, toolData, style = DEFAULT_STYLE) {
+	const imports = generateFunctionToolImports(toolId, toolData, style);
+	const definition = generateFunctionToolDefinition(toolId, toolData, style);
+	return imports.join("\n") + "\n\n" + definition + "\n";
+}
+
+//#endregion
+export { generateFunctionToolDefinition, generateFunctionToolFile, generateFunctionToolImports };

package/dist/commands/pull-v3/components/mcp-tool-generator.js

@@ -0,0 +1,86 @@
+//#region src/commands/pull-v3/components/mcp-tool-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}`;
+}
+/**
+* Generate MCP Tool Definition using mcpTool() builder function
+*/
+function generateMcpToolDefinition(toolId, toolData, style = DEFAULT_STYLE, registry) {
+	if (!toolId || typeof toolId !== "string") throw new Error("toolId is required and must be a string");
+	if (!toolData || typeof toolData !== "object") throw new Error(`toolData is required for MCP tool '${toolId}'`);
+	const requiredFields = ["name"];
+	const serverUrl = toolData.config?.mcp?.server?.url || toolData.serverUrl;
+	const missingFields = requiredFields.filter((field) => !toolData[field] || toolData[field] === null || toolData[field] === void 0);
+	if (!serverUrl) missingFields.push("serverUrl (from config.mcp.server.url or serverUrl)");
+	if (missingFields.length > 0) throw new Error(`Missing required fields for MCP tool '${toolId}': ${missingFields.join(", ")}`);
+	const { quotes, semicolons, indentation } = style;
+	const q = quotes === "single" ? "'" : "\"";
+	const semi = semicolons ? ";" : "";
+	const toolVarName = toCamelCase(toolId);
+	const lines = [];
+	lines.push(`export const ${toolVarName} = mcpTool({`);
+	lines.push(`${indentation}id: ${formatString(toolId, q)},`);
+	lines.push(`${indentation}name: ${formatString(toolData.name, q)},`);
+	if (toolData.config?.mcp && typeof toolData.config.mcp === "object") {
+		const mcpConfig = toolData.config.mcp;
+		lines.push(`${indentation}serverUrl: ${formatString(mcpConfig.server?.url, q)},`);
+		if (mcpConfig.transport) lines.push(`${indentation}transport: ${JSON.stringify(mcpConfig.transport, null, 2)},`);
+		if (mcpConfig.activeTools && Array.isArray(mcpConfig.activeTools)) lines.push(`${indentation}activeTools: ${JSON.stringify(mcpConfig.activeTools)},`);
+	}
+	if (toolData.description) lines.push(`${indentation}description: ${formatString(toolData.description, q, true)},`);
+	if (toolData.imageUrl) lines.push(`${indentation}imageUrl: ${formatString(toolData.imageUrl, q)},`);
+	if (toolData.headers && typeof toolData.headers === "object") {
+		const formattedHeaders = JSON.stringify(toolData.headers, null, 2).split("\n").map((line, index) => {
+			if (index === 0) return `${indentation}headers: ${line}`;
+			return `${indentation}${line}`;
+		}).join("\n");
+		lines.push(formattedHeaders + ",");
+	}
+	if (toolData.credential) if (typeof toolData.credential === "object") {
+		const credentialStr = JSON.stringify(toolData.credential);
+		lines.push(`${indentation}credential: ${credentialStr},`);
+	} else lines.push(`${indentation}credential: ${toolData.credential},`);
+	else if (toolData.credentialReferenceId && registry) {
+		const validKey = registry.getVariableName(toolData.credentialReferenceId, "credentials");
+		lines.push(`${indentation}credential: envSettings.getEnvironmentCredential(${formatString(validKey, 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 MCP tool file
+*/
+function generateMcpToolImports(toolId, toolData, style = DEFAULT_STYLE) {
+	const { quotes, semicolons } = style;
+	const q = quotes === "single" ? "'" : "\"";
+	const semi = semicolons ? ";" : "";
+	const imports = [];
+	imports.push(`import { mcpTool } from ${q}@inkeep/agents-sdk${q}${semi}`);
+	if (toolData.credentialReferenceId) imports.push(`import { envSettings } from ${q}../environments${q}${semi}`);
+	return imports;
+}
+/**
+* Generate complete MCP tool file (imports + definition)
+*/
+function generateMcpToolFile(toolId, toolData, style = DEFAULT_STYLE, registry) {
+	const imports = generateMcpToolImports(toolId, toolData, style);
+	const definition = generateMcpToolDefinition(toolId, toolData, style, registry);
+	return imports.join("\n") + "\n\n" + definition + "\n";
+}
+
+//#endregion
+export { generateMcpToolDefinition, generateMcpToolFile, generateMcpToolImports };