@inkeep/agents-cli 0.0.0-dev-20260224063043 → 0.0.0-dev-20260224081637

package/dist/agents-cli/package.js

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

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

@@ -1,4 +1,4 @@
-import { addObjectEntries, addReferenceGetterProperty, addStringProperty, collectTemplateVariableNames, createFactoryDefinition, formatStringLiteral, formatTemplate, isPlainObject, toCamelCase } from "./utils.js";
+import { addObjectEntries, addReferenceGetterProperty, addStringProperty, collectTemplateVariableNames, createFactoryDefinition, createUniqueReferenceName, formatStringLiteral, formatTemplate, isPlainObject, toCamelCase } from "./utils.js";
 import { z } from "zod";
 import { SyntaxKind } from "ts-morph";
 
@@ -253,22 +253,6 @@ function createReferenceNameMap(ids, reservedNames, conflictSuffix) {
 	}
 	return map;
 }
-function createUniqueReferenceName(baseName, reservedNames, conflictSuffix) {
-	if (!reservedNames.has(baseName)) {
-		reservedNames.add(baseName);
-		return baseName;
-	}
-	const baseCandidate = `${baseName}${conflictSuffix}`;
-	if (!reservedNames.has(baseCandidate)) {
-		reservedNames.add(baseCandidate);
-		return baseCandidate;
-	}
-	let index = 2;
-	while (reservedNames.has(`${baseCandidate}${index}`)) index += 1;
-	const uniqueName = `${baseCandidate}${index}`;
-	reservedNames.add(uniqueName);
-	return uniqueName;
-}
 
 //#endregion
 export { generateAgentDefinition };

package/dist/commands/pull-v4/introspect-generator.js

@@ -5,6 +5,7 @@ import { generateArtifactComponentDefinition } from "./artifact-component-genera
 import { generateContextConfigDefinition } from "./context-config-generator.js";
 import { generateCredentialDefinition } from "./credential-generator.js";
 import { generateDataComponentDefinition } from "./data-component-generator.js";
+import { generateMcpToolDefinition } from "./mcp-tool-generator.js";
 import { mergeGeneratedModule } from "./module-merge.js";
 import { generateProjectDefinition } from "./project-generator.js";
 import { generateStatusComponentDefinition } from "./status-component-generator.js";
@@ -61,6 +62,11 @@ function createGenerationTasks() {
 			collect: collectDataComponentRecords,
 			generate: generateDataComponentDefinition
 		},
+		{
+			type: "tool",
+			collect: collectToolRecords,
+			generate: generateMcpToolDefinition
+		},
 		{
 			type: "context-config",
 			collect: collectContextConfigRecords,
@@ -154,6 +160,16 @@ function collectContextConfigRecords(context) {
 	}
 	return [...contextConfigRecordsById.values()];
 }
+function collectToolRecords(context) {
+	return Object.entries(context.project.tools ?? {}).map(([toolId, toolData]) => ({
+		id: toolId,
+		filePath: resolveRecordFilePath(context, "tools", toolId, join(context.paths.toolsDir, `${toolId}.ts`)),
+		payload: {
+			mcpToolId: toolId,
+			...toolData
+		}
+	}));
+}
 function collectContextConfigCredentialReferenceOverrides(context, contextConfigData) {
 	const registry = context.existingComponentRegistry;
 	if (!registry) return;
@@ -360,7 +376,6 @@ function isAgentComplete(agentData) {
 }
 function collectUnsupportedComponentCounts(project) {
 	return {
-		tools: getObjectKeys(project.tools).length,
 		functionTools: getObjectKeys(project.functionTools).length,
 		functions: getObjectKeys(project.functions).length,
 		externalAgents: getObjectKeys(project.externalAgents).length

package/dist/commands/pull-v4/mcp-tool-generator.js

@@ -2,7 +2,7 @@ import { addValueToObject, createFactoryDefinition, formatInlineLiteral, formatS
 import { z } from "zod";
 
 //#region src/commands/pull-v4/mcp-tool-generator.ts
-const McpToolSchema = z.looseObject({
+const McpToolSchema = z.object({
 	mcpToolId: z.string().nonempty(),
 	name: z.string().nonempty(),
 	description: z.string().nullable().optional(),
@@ -14,10 +14,10 @@ const McpToolSchema = z.looseObject({
 	serverUrl: z.string().optional(),
 	transport: z.object({ type: z.string() }).optional(),
 	activeTools: z.array(z.unknown()).optional(),
-	imageUrl: z.string().optional(),
+	imageUrl: z.string().nullish(),
 	headers: z.unknown().optional(),
 	credential: z.unknown().optional(),
-	credentialReferenceId: z.string().optional()
+	credentialReferenceId: z.string().nullish()
 }).superRefine((value, context) => {
 	if (!resolveServerUrl(value)) context.addIssue({
 		code: "custom",

package/dist/commands/pull-v4/module-merge.js

@@ -19,6 +19,7 @@ function mergeImports(existingFile, generatedFile) {
 		const matchingImports = existingFile.getImportDeclarations().filter((existingImport) => existingImport.getModuleSpecifierValue() === moduleSpecifier);
 		if (!matchingImports.length) {
 			if (areGeneratedImportBindingsAlreadyPresent(existingFile, generatedImport)) continue;
+			if (hasGeneratedImportBindingConflicts(existingFile, generatedImport)) continue;
 			existingFile.addImportDeclaration(generatedImport.getStructure());
 			continue;
 		}
@@ -29,20 +30,30 @@ function mergeImports(existingFile, generatedFile) {
 		}
 		if (!generatedImport.isTypeOnly() && targetImport.isTypeOnly()) targetImport.setIsTypeOnly(false);
 		const generatedDefaultImport = generatedImport.getDefaultImport();
-		if (generatedDefaultImport && !targetImport.getDefaultImport()) targetImport.setDefaultImport(generatedDefaultImport.getText());
+		if (generatedDefaultImport && !targetImport.getDefaultImport()) {
+			const defaultImportName = generatedDefaultImport.getText();
+			if (!hasTopLevelDeclarationWithName(existingFile, defaultImportName)) targetImport.setDefaultImport(defaultImportName);
+		}
 		const generatedNamespaceImport = generatedImport.getNamespaceImport();
-		if (generatedNamespaceImport && !targetImport.getNamespaceImport()) targetImport.setNamespaceImport(generatedNamespaceImport.getText());
+		if (generatedNamespaceImport && !targetImport.getNamespaceImport()) {
+			const namespaceImportName = generatedNamespaceImport.getText();
+			if (!hasTopLevelDeclarationWithName(existingFile, namespaceImportName)) targetImport.setNamespaceImport(namespaceImportName);
+		}
 		for (const generatedNamedImport of generatedImport.getNamedImports()) {
 			const generatedName = generatedNamedImport.getName();
 			const generatedAlias = generatedNamedImport.getAliasNode()?.getText();
 			const generatedIsTypeOnly = generatedNamedImport.isTypeOnly();
+			const generatedBindingName = generatedAlias ?? generatedName;
 			if (!targetImport.getNamedImports().some((existingNamedImport) => {
 				return existingNamedImport.getName() === generatedName && existingNamedImport.getAliasNode()?.getText() === generatedAlias && existingNamedImport.isTypeOnly() === generatedIsTypeOnly;
-			})) targetImport.addNamedImport({
-				name: generatedName,
-				alias: generatedAlias,
-				isTypeOnly: generatedIsTypeOnly
-			});
+			})) {
+				if (hasTopLevelDeclarationWithName(existingFile, generatedBindingName)) continue;
+				targetImport.addNamedImport({
+					name: generatedName,
+					alias: generatedAlias,
+					isTypeOnly: generatedIsTypeOnly
+				});
+			}
 		}
 	}
 }
@@ -63,6 +74,11 @@ function areGeneratedImportBindingsAlreadyPresent(existingFile, generatedImport)
 	const existingImports = existingFile.getImportDeclarations();
 	return generatedBindings.every((binding) => existingImports.some((existingImport) => importHasBinding(existingImport, binding)));
 }
+function hasGeneratedImportBindingConflicts(existingFile, generatedImport) {
+	const generatedBindings = getImportBindingNames(generatedImport);
+	if (!generatedBindings.length) return false;
+	return generatedBindings.some((binding) => hasTopLevelDeclarationWithName(existingFile, binding));
+}
 function getImportBindingNames(importDeclaration) {
 	const bindings = [];
 	const defaultImport = importDeclaration.getDefaultImport();
@@ -79,6 +95,16 @@ function importHasBinding(importDeclaration, bindingName) {
 		return (namedImport.getAliasNode()?.getText() ?? namedImport.getName()) === bindingName;
 	});
 }
+function hasTopLevelDeclarationWithName(existingFile, declarationName) {
+	if (existingFile.getVariableDeclaration(declarationName)) return true;
+	if (existingFile.getFunction(declarationName)) return true;
+	if (existingFile.getClass(declarationName)) return true;
+	if (existingFile.getInterface(declarationName)) return true;
+	if (existingFile.getTypeAlias(declarationName)) return true;
+	if (existingFile.getEnum(declarationName)) return true;
+	if (existingFile.getModule(declarationName)) return true;
+	return false;
+}
 function upsertStatement(existingFile, generatedStatement) {
 	if (Node.isVariableStatement(generatedStatement)) {
 		upsertVariableStatement(existingFile, generatedStatement);

package/dist/commands/pull-v4/project-generator.js

@@ -1,4 +1,4 @@
-import { addReferenceGetterProperty, addValueToObject, convertNullToUndefined, createFactoryDefinition, formatStringLiteral, hasReferences, resolveReferenceName, toCamelCase } from "./utils.js";
+import { addReferenceGetterProperty, addValueToObject, convertNullToUndefined, createFactoryDefinition, createUniqueReferenceName, formatStringLiteral, hasReferences, resolveReferenceName, toCamelCase } from "./utils.js";
 import { z } from "zod";
 
 //#region src/commands/pull-v4/project-generator.ts
@@ -38,10 +38,12 @@ function generateProjectDefinition(data) {
 	if (!result.success) throw new Error(`Validation failed for project:
 ${z.prettifyError(result.error)}`);
 	const parsed = result.data;
+	const projectVariableName = toCamelCase(parsed.projectId);
 	const { sourceFile, configObject } = createFactoryDefinition({
 		importName: "project",
-		variableName: toCamelCase(parsed.projectId)
+		variableName: projectVariableName
 	});
+	const reservedReferenceNames = new Set([projectVariableName]);
 	if (hasReferences(parsed.skills)) {
 		sourceFile.getImportDeclarationOrThrow("@inkeep/agents-sdk").addNamedImport("loadSkills");
 		sourceFile.addImportDeclaration({
@@ -59,42 +61,64 @@ ${z.prettifyError(result.error)}`);
 		initializer: `() => loadSkills(path.join(${formatStringLiteral(projectId)}, 'skills'))`
 	});
 	if (hasReferences(agents)) {
-		addReferenceImports(sourceFile, agents, "./agents", referenceOverrides?.agents);
-		addReferenceGetterProperty(configObject, "agents", toReferenceNames(agents, referenceOverrides?.agents));
+		const resolvedReferences = createResolvedReferences(agents, referenceOverrides?.agents, reservedReferenceNames, "Agent");
+		addReferenceImports(sourceFile, resolvedReferences, "./agents");
+		addReferenceGetterProperty(configObject, "agents", toReferenceNames(resolvedReferences));
 	}
 	if (hasReferences(tools)) {
-		addReferenceImports(sourceFile, tools, "./tools", referenceOverrides?.tools);
-		addReferenceGetterProperty(configObject, "tools", toReferenceNames(tools, referenceOverrides?.tools));
+		const resolvedReferences = createResolvedReferences(tools, referenceOverrides?.tools, reservedReferenceNames, "Tool");
+		addReferenceImports(sourceFile, resolvedReferences, "./tools");
+		addReferenceGetterProperty(configObject, "tools", toReferenceNames(resolvedReferences));
 	}
 	if (hasReferences(externalAgents)) {
-		addReferenceImports(sourceFile, externalAgents, "./external-agents", referenceOverrides?.externalAgents);
-		addReferenceGetterProperty(configObject, "externalAgents", toReferenceNames(externalAgents, referenceOverrides?.externalAgents));
+		const resolvedReferences = createResolvedReferences(externalAgents, referenceOverrides?.externalAgents, reservedReferenceNames, "ExternalAgent");
+		addReferenceImports(sourceFile, resolvedReferences, "./external-agents");
+		addReferenceGetterProperty(configObject, "externalAgents", toReferenceNames(resolvedReferences));
 	}
 	if (hasReferences(dataComponents)) {
-		addReferenceImports(sourceFile, dataComponents, "./data-components", referenceOverrides?.dataComponents);
-		addReferenceGetterProperty(configObject, "dataComponents", toReferenceNames(dataComponents, referenceOverrides?.dataComponents));
+		const resolvedReferences = createResolvedReferences(dataComponents, referenceOverrides?.dataComponents, reservedReferenceNames, "DataComponent");
+		addReferenceImports(sourceFile, resolvedReferences, "./data-components");
+		addReferenceGetterProperty(configObject, "dataComponents", toReferenceNames(resolvedReferences));
 	}
 	if (hasReferences(artifactComponents)) {
-		addReferenceImports(sourceFile, artifactComponents, "./artifact-components", referenceOverrides?.artifactComponents);
-		addReferenceGetterProperty(configObject, "artifactComponents", toReferenceNames(artifactComponents, referenceOverrides?.artifactComponents));
+		const resolvedReferences = createResolvedReferences(artifactComponents, referenceOverrides?.artifactComponents, reservedReferenceNames, "ArtifactComponent");
+		addReferenceImports(sourceFile, resolvedReferences, "./artifact-components");
+		addReferenceGetterProperty(configObject, "artifactComponents", toReferenceNames(resolvedReferences));
 	}
 	if (hasReferences(credentialReferences)) {
-		addReferenceImports(sourceFile, credentialReferences, "./credentials", referenceOverrides?.credentialReferences);
-		addReferenceGetterProperty(configObject, "credentialReferences", toReferenceNames(credentialReferences, referenceOverrides?.credentialReferences));
+		const resolvedReferences = createResolvedReferences(credentialReferences, referenceOverrides?.credentialReferences, reservedReferenceNames, "CredentialReference");
+		addReferenceImports(sourceFile, resolvedReferences, "./credentials");
+		addReferenceGetterProperty(configObject, "credentialReferences", toReferenceNames(resolvedReferences));
 	}
 	return sourceFile;
 }
-function addReferenceImports(sourceFile, references, basePath, referenceOverrides) {
-	for (const reference of references) {
-		const referenceName = resolveReferenceName(reference, [referenceOverrides]);
-		sourceFile.addImportDeclaration({
-			namedImports: [referenceName],
-			moduleSpecifier: `${basePath}/${reference}`
+function addReferenceImports(sourceFile, references, basePath) {
+	for (const reference of references) sourceFile.addImportDeclaration({
+		namedImports: [reference.importName === reference.localName ? reference.importName : {
+			name: reference.importName,
+			alias: reference.localName
+		}],
+		moduleSpecifier: `${basePath}/${reference.id}`
+	});
+}
+function toReferenceNames(references) {
+	return references.map((reference) => reference.localName);
+}
+function createResolvedReferences(references, referenceOverrides, reservedReferenceNames, suffix) {
+	const seenIds = /* @__PURE__ */ new Set();
+	const resolvedReferences = [];
+	for (const referenceId of references) {
+		if (seenIds.has(referenceId)) continue;
+		seenIds.add(referenceId);
+		const importName = resolveReferenceName(referenceId, [referenceOverrides]);
+		const localName = createUniqueReferenceName(importName, reservedReferenceNames, suffix);
+		resolvedReferences.push({
+			id: referenceId,
+			importName,
+			localName
 		});
 	}
-}
-function toReferenceNames(references, referenceOverrides) {
-	return references.map((reference) => resolveReferenceName(reference, [referenceOverrides]));
+	return resolvedReferences;
 }
 
 //#endregion

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

@@ -54,12 +54,113 @@ function generateSubAgentDefinition(data) {
 		namedImports: [...new Set(namedImports)],
 		moduleSpecifier: `../context-configs/${parsed.contextConfigId}`
 	});
+	addCanUseToolImports(sourceFile, parsed.canUse, parsed.referenceOverrides?.tools);
+	addDataComponentImports(sourceFile, parsed.dataComponents, parsed.referenceOverrides?.dataComponents);
+	addArtifactComponentImports(sourceFile, parsed.artifactComponents, parsed.referenceOverrides?.artifactComponents);
+	addDelegateTargetImports(sourceFile, {
+		currentSubAgentId: parsed.id,
+		canDelegateTo: parsed.canDelegateTo,
+		canTransferTo: parsed.canTransferTo,
+		referenceOverrides: {
+			subAgents: parsed.referenceOverrides?.subAgents,
+			agents: parsed.referenceOverrides?.agents,
+			externalAgents: parsed.referenceOverrides?.externalAgents
+		}
+	});
 	writeSubAgentConfig(configObject, {
 		contextReference: parsed.contextConfigReference?.name,
 		headersReference: parsed.contextConfigHeadersReference?.name
 	}, parsed);
 	return sourceFile;
 }
+function addCanUseToolImports(sourceFile, canUse, toolReferenceOverrides) {
+	const toolImportsById = /* @__PURE__ */ new Map();
+	for (const item of canUse ?? []) {
+		const toolId = typeof item === "string" ? item : isPlainObject(item) && typeof item.toolId === "string" ? item.toolId : void 0;
+		if (!toolId || toolImportsById.has(toolId)) continue;
+		toolImportsById.set(toolId, resolveReferenceName(toolId, [toolReferenceOverrides]));
+	}
+	for (const [toolId, referenceName] of toolImportsById) sourceFile.addImportDeclaration({
+		namedImports: [referenceName],
+		moduleSpecifier: `../../tools/${toolId}`
+	});
+}
+function addDataComponentImports(sourceFile, dataComponents, dataComponentReferenceOverrides) {
+	addReferenceImports(sourceFile, dataComponents, "../../data-components", dataComponentReferenceOverrides);
+}
+function addArtifactComponentImports(sourceFile, artifactComponents, artifactComponentReferenceOverrides) {
+	addReferenceImports(sourceFile, artifactComponents, "../../artifact-components", artifactComponentReferenceOverrides);
+}
+function addReferenceImports(sourceFile, references, basePath, referenceOverrides) {
+	const importByReferenceId = /* @__PURE__ */ new Map();
+	for (const referenceId of references ?? []) {
+		if (!referenceId || importByReferenceId.has(referenceId)) continue;
+		importByReferenceId.set(referenceId, resolveReferenceName(referenceId, [referenceOverrides]));
+	}
+	for (const [referenceId, referenceName] of importByReferenceId) sourceFile.addImportDeclaration({
+		namedImports: [referenceName],
+		moduleSpecifier: `${basePath}/${referenceId}`
+	});
+}
+function addDelegateTargetImports(sourceFile, options) {
+	const importsByTarget = /* @__PURE__ */ new Map();
+	for (const item of options.canDelegateTo ?? []) {
+		const resolvedTarget = resolveDelegateTargetImport(item, options.referenceOverrides);
+		if (!resolvedTarget) continue;
+		if (resolvedTarget.type === "subAgents" && resolvedTarget.id === options.currentSubAgentId) continue;
+		importsByTarget.set(`${resolvedTarget.type}:${resolvedTarget.id}`, resolvedTarget);
+	}
+	for (const targetId of options.canTransferTo ?? []) {
+		const resolvedTarget = resolveDelegateTargetImport(targetId, options.referenceOverrides);
+		if (!resolvedTarget) continue;
+		if (resolvedTarget.type === "subAgents" && resolvedTarget.id === options.currentSubAgentId) continue;
+		importsByTarget.set(`${resolvedTarget.type}:${resolvedTarget.id}`, resolvedTarget);
+	}
+	for (const target of importsByTarget.values()) sourceFile.addImportDeclaration({
+		namedImports: [target.name],
+		moduleSpecifier: resolveDelegateImportModuleSpecifier(target.type, target.id)
+	});
+}
+function resolveDelegateTargetImport(canDelegateToEntry, referenceOverrides) {
+	if (typeof canDelegateToEntry === "string") {
+		const resolvedType = resolveDelegateTargetType(canDelegateToEntry, referenceOverrides);
+		if (!resolvedType) return;
+		return {
+			type: resolvedType,
+			id: canDelegateToEntry,
+			name: resolveReferenceName(canDelegateToEntry, [referenceOverrides[resolvedType]])
+		};
+	}
+	if (!isPlainObject(canDelegateToEntry)) return;
+	if (typeof canDelegateToEntry.subAgentId === "string") return {
+		type: "subAgents",
+		id: canDelegateToEntry.subAgentId,
+		name: resolveReferenceName(canDelegateToEntry.subAgentId, [referenceOverrides.subAgents])
+	};
+	if (typeof canDelegateToEntry.agentId === "string") return {
+		type: "agents",
+		id: canDelegateToEntry.agentId,
+		name: resolveReferenceName(canDelegateToEntry.agentId, [referenceOverrides.agents])
+	};
+	if (typeof canDelegateToEntry.externalAgentId === "string") return {
+		type: "externalAgents",
+		id: canDelegateToEntry.externalAgentId,
+		name: resolveReferenceName(canDelegateToEntry.externalAgentId, [referenceOverrides.externalAgents])
+	};
+}
+function resolveDelegateTargetType(targetId, referenceOverrides) {
+	if (referenceOverrides.subAgents?.[targetId]) return "subAgents";
+	if (referenceOverrides.agents?.[targetId]) return "agents";
+	if (referenceOverrides.externalAgents?.[targetId]) return "externalAgents";
+	return "subAgents";
+}
+function resolveDelegateImportModuleSpecifier(type, id) {
+	switch (type) {
+		case "subAgents": return `./${id}`;
+		case "agents": return `../${id}`;
+		case "externalAgents": return `../../external-agents/${id}`;
+	}
+}
 function writeSubAgentConfig(configObject, templateReferences, { dataComponents, name, canDelegateTo, canTransferTo, skills, artifactComponents, canUse, referenceOverrides, contextConfigId: _contextConfigId, contextConfigReference: _contextConfigReference, contextConfigHeadersReference: _contextConfigHeadersReference, ...rest }) {
 	rest = { ...rest };
 	rest.prompt &&= formatTemplate(rest.prompt, templateReferences);

package/dist/commands/pull-v4/utils.js

@@ -55,6 +55,22 @@ function toCamelCase(input) {
 	const result = input.replace(/[^a-zA-Z0-9](.)/g, (_, char) => char.toUpperCase()).replace(/^[0-9]/, "_$&");
 	return result.charAt(0).toLowerCase() + result.slice(1);
 }
+function createUniqueReferenceName(baseName, reservedNames, conflictSuffix) {
+	if (!reservedNames.has(baseName)) {
+		reservedNames.add(baseName);
+		return baseName;
+	}
+	const baseCandidate = `${baseName}${conflictSuffix}`;
+	if (!reservedNames.has(baseCandidate)) {
+		reservedNames.add(baseCandidate);
+		return baseCandidate;
+	}
+	let index = 2;
+	while (reservedNames.has(`${baseCandidate}${index}`)) index += 1;
+	const uniqueName = `${baseCandidate}${index}`;
+	reservedNames.add(uniqueName);
+	return uniqueName;
+}
 function resolveReferenceName(referenceId, referenceOverrides) {
 	for (const overrideMap of referenceOverrides) {
 		const overrideName = overrideMap?.[referenceId];
@@ -216,4 +232,4 @@ function hasReferences(references) {
 }
 
 //#endregion
-export { TEMPLATE_VARIABLE_REGEX, addFactoryConfigVariable, addObjectEntries, addReferenceGetterProperty, addStringProperty, addValueToObject, collectTemplateVariableNames, convertJsonSchemaToZodSafe, convertNullToUndefined, createFactoryDefinition, createInMemoryProject, expectSnapshots, formatInlineLiteral, formatPropertyName, formatStringLiteral, formatTemplate, hasReferences, isPlainObject, resolveReferenceName, toCamelCase };
+export { TEMPLATE_VARIABLE_REGEX, addFactoryConfigVariable, addObjectEntries, addReferenceGetterProperty, addStringProperty, addValueToObject, collectTemplateVariableNames, convertJsonSchemaToZodSafe, convertNullToUndefined, createFactoryDefinition, createInMemoryProject, createUniqueReferenceName, expectSnapshots, formatInlineLiteral, formatPropertyName, formatStringLiteral, formatTemplate, hasReferences, isPlainObject, resolveReferenceName, toCamelCase };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inkeep/agents-cli",
-  "version": "0.0.0-dev-20260224063043",
+  "version": "0.0.0-dev-20260224081637",
   "description": "Inkeep CLI tool",
   "type": "module",
   "main": "./dist/index.js",
@@ -40,8 +40,8 @@
     "tsx": "^4.20.5",
     "yaml": "^2.7.0",
     "zod": "^4.3.6",
-    "@inkeep/agents-core": "^0.0.0-dev-20260224063043",
-    "@inkeep/agents-sdk": "^0.0.0-dev-20260224063043"
+    "@inkeep/agents-core": "^0.0.0-dev-20260224081637",
+    "@inkeep/agents-sdk": "^0.0.0-dev-20260224081637"
   },
   "devDependencies": {
     "diff": "^8.0.3",
@@ -53,7 +53,7 @@
     "vitest": "^3.2.4"
   },
   "peerDependencies": {
-    "@inkeep/agents-manage-ui": "0.0.0-dev-20260224063043"
+    "@inkeep/agents-manage-ui": "0.0.0-dev-20260224081637"
   },
   "publishConfig": {
     "access": "public",