@inkeep/agents-sdk 0.39.4 → 0.40.0

package/dist/subAgent.js

@@ -0,0 +1,616 @@
+import { FunctionTool } from "./function-tool.js";
+import { ArtifactComponent } from "./artifact-component.js";
+import { DataComponent } from "./data-component.js";
+import { Tool } from "./tool.js";
+import { isAgentMcpConfig, normalizeAgentCanUseType } from "./utils/tool-normalization.js";
+import { getLogger } from "@inkeep/agents-core";
+import { convertZodToJsonSchemaWithPreview, isZodSchema } from "@inkeep/agents-core/utils/schema-conversion";
+
+//#region src/subAgent.ts
+const logger = getLogger("agent");
+function resolveGetter(value) {
+	if (typeof value === "function") return value();
+	return value;
+}
+var SubAgent = class {
+	config;
+	type = "internal";
+	baseURL;
+	tenantId;
+	projectId;
+	initialized = false;
+	constructor(config) {
+		this.config = {
+			...config,
+			type: "internal"
+		};
+		this.baseURL = process.env.INKEEP_API_URL || "http://localhost:3002";
+		this.tenantId = "default";
+		this.projectId = "default";
+		logger.info({
+			tenantId: this.tenantId,
+			subAgentId: this.config.id,
+			agentName: config.name
+		}, "Agent constructor initialized");
+	}
+	setContext(tenantId, projectId, baseURL) {
+		this.tenantId = tenantId;
+		this.projectId = projectId;
+		if (baseURL) this.baseURL = baseURL;
+	}
+	getId() {
+		return this.config.id;
+	}
+	getName() {
+		return this.config.name;
+	}
+	getInstructions() {
+		return this.config.prompt || "";
+	}
+	/**
+	* Get the agent's description (the human-readable description field)
+	*/
+	getDescription() {
+		return this.config.description || "";
+	}
+	getTools() {
+		const tools = resolveGetter(this.config.canUse);
+		if (!tools) return {};
+		if (!Array.isArray(tools)) throw new Error("tools getter must return an array");
+		const toolRecord = {};
+		for (const tool of tools) if (tool && typeof tool === "object") {
+			let id;
+			let toolInstance;
+			if (isAgentMcpConfig(tool)) {
+				id = tool.server.getId();
+				toolInstance = tool.server;
+				toolInstance.selectedTools = tool.selectedTools;
+				toolInstance.headers = tool.headers;
+				toolInstance.toolPolicies = tool.toolPolicies;
+			} else {
+				toolInstance = tool;
+				id = toolInstance.getId();
+			}
+			if (id) toolRecord[id] = toolInstance;
+		}
+		return toolRecord;
+	}
+	getModels() {
+		return this.config.models;
+	}
+	setModels(models) {
+		this.config.models = models;
+	}
+	getTransfers() {
+		return typeof this.config.canTransferTo === "function" ? this.config.canTransferTo() : [];
+	}
+	getSubAgentDelegates() {
+		return typeof this.config.canDelegateTo === "function" ? this.config.canDelegateTo().filter((delegate) => {
+			if (typeof delegate === "object" && "externalAgent" in delegate) return false;
+			if (typeof delegate === "object" && "agent" in delegate) return false;
+			if (typeof delegate === "object" && "toFullAgentDefinition" in delegate) return false;
+			if (typeof delegate === "object" && "type" in delegate && delegate.type === "external") return false;
+			return true;
+		}) : [];
+	}
+	getExternalAgentDelegates() {
+		if (typeof this.config.canDelegateTo !== "function") return [];
+		return this.config.canDelegateTo().filter((delegate) => {
+			if (typeof delegate === "object" && "externalAgent" in delegate) return true;
+			if (typeof delegate === "object" && "type" in delegate && delegate.type === "external") return true;
+			return false;
+		}).map((delegate) => {
+			if ("externalAgent" in delegate) return delegate;
+			return {
+				externalAgent: delegate,
+				headers: void 0
+			};
+		});
+	}
+	getTeamAgentDelegates() {
+		if (typeof this.config.canDelegateTo !== "function") return [];
+		return this.config.canDelegateTo().filter((delegate) => {
+			if (typeof delegate === "object" && "agent" in delegate) return true;
+			if (typeof delegate === "object" && "toFullAgentDefinition" in delegate) return true;
+			return false;
+		}).map((delegate) => {
+			if ("agent" in delegate) return delegate;
+			return {
+				agent: delegate,
+				headers: void 0
+			};
+		});
+	}
+	getDelegates() {
+		return [
+			...this.getSubAgentDelegates(),
+			...this.getTeamAgentDelegates(),
+			...this.getExternalAgentDelegates()
+		];
+	}
+	getDataComponents() {
+		return (resolveGetter(this.config.dataComponents) || []).map((comp) => {
+			if (comp && typeof comp.getId === "function") return {
+				id: comp.getId(),
+				name: comp.getName(),
+				description: comp.getDescription(),
+				props: comp.getProps(),
+				render: comp.getRender?.() || null
+			};
+			if (comp && typeof comp === "object" && comp.props && isZodSchema(comp.props)) return {
+				id: comp.id,
+				name: comp.name,
+				description: comp.description,
+				props: convertZodToJsonSchemaWithPreview(comp.props),
+				render: comp.render || null
+			};
+			return comp;
+		});
+	}
+	getArtifactComponents() {
+		return (resolveGetter(this.config.artifactComponents) || []).map((comp) => {
+			if (comp && typeof comp.getId === "function") return {
+				id: comp.getId(),
+				name: comp.getName(),
+				description: comp.getDescription(),
+				props: comp.getProps?.() || comp.props
+			};
+			if (comp && typeof comp === "object" && comp.props && isZodSchema(comp.props)) return {
+				id: comp.id,
+				name: comp.name,
+				description: comp.description,
+				props: convertZodToJsonSchemaWithPreview(comp.props)
+			};
+			return comp;
+		});
+	}
+	addTool(_name, tool) {
+		const existingTools = this.config.canUse ? this.config.canUse() : [];
+		this.config.canUse = () => [...existingTools, tool];
+	}
+	addTransfer(...agents) {
+		if (typeof this.config.canTransferTo === "function") {
+			const existingTransfers = this.config.canTransferTo;
+			this.config.canTransferTo = () => [...existingTransfers(), ...agents];
+		} else this.config.canTransferTo = () => agents;
+	}
+	addDelegate(...agents) {
+		if (typeof this.config.canDelegateTo === "function") {
+			const existingDelegates = this.config.canDelegateTo;
+			this.config.canDelegateTo = () => [...existingDelegates(), ...agents];
+		} else this.config.canDelegateTo = () => agents;
+	}
+	async init() {
+		if (this.initialized) return;
+		try {
+			await this.upsertAgent();
+			await this.loadDataComponents();
+			await this.loadArtifactComponents();
+			await this.saveToolsAndRelations();
+			await this.saveDataComponents();
+			await this.saveArtifactComponents();
+			logger.info({ subAgentId: this.getId() }, "Agent initialized successfully");
+			this.initialized = true;
+		} catch (error) {
+			logger.error({
+				subAgentId: this.getId(),
+				error: error instanceof Error ? error.message : "Unknown error"
+			}, "Failed to initialize agent");
+			throw error;
+		}
+	}
+	async upsertAgent() {
+		const agentData = {
+			id: this.getId(),
+			name: this.config.name,
+			description: this.config.description || "",
+			prompt: this.config.prompt || "",
+			conversationHistoryConfig: this.config.conversationHistoryConfig,
+			models: this.config.models,
+			stopWhen: this.config.stopWhen
+		};
+		const updateResponse = await fetch(`${this.baseURL}/tenants/${this.tenantId}/agents/${this.getId()}`, {
+			method: "PUT",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(agentData)
+		});
+		if (updateResponse.ok) {
+			logger.info({ subAgentId: this.getId() }, "Agent updated successfully");
+			return;
+		}
+		if (updateResponse.status === 404) {
+			logger.info({ subAgentId: this.getId() }, "Agent not found, creating new agent");
+			const createResponse = await fetch(`${this.baseURL}/tenants/${this.tenantId}/agents`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify(agentData)
+			});
+			if (!createResponse.ok) {
+				const errorText$1 = await createResponse.text().catch(() => "Unknown error");
+				throw new Error(`Failed to create agent: ${createResponse.status} ${createResponse.statusText} - ${errorText$1}`);
+			}
+			logger.info({ subAgentId: this.getId() }, "Agent created successfully");
+			return;
+		}
+		const errorText = await updateResponse.text().catch(() => "Unknown error");
+		throw new Error(`Failed to update agent: ${updateResponse.status} ${updateResponse.statusText} - ${errorText}`);
+	}
+	async saveToolsAndRelations() {
+		if (this.config.canUse) {
+			const tools = resolveGetter(this.config.canUse);
+			if (tools && Array.isArray(tools)) for (let i = 0; i < tools.length; i++) {
+				const toolConfig = tools[i];
+				try {
+					const normalizedTool = normalizeAgentCanUseType(toolConfig, `tool-${i}`);
+					await this.createTool(normalizedTool.toolId, toolConfig);
+				} catch (error) {
+					logger.error({
+						toolId: isAgentMcpConfig(toolConfig) ? toolConfig.server.getId() : toolConfig.getId?.(),
+						error: error instanceof Error ? error.message : "Unknown error"
+					}, "Tool creation failed");
+					throw error;
+				}
+			}
+		}
+	}
+	async saveDataComponents() {
+		logger.info({ dataComponents: this.config.dataComponents }, "dataComponents and config");
+		const components = resolveGetter(this.config.dataComponents);
+		if (components) for (const dataComponent of components) {
+			const plainComponent = dataComponent && typeof dataComponent.getId === "function" ? {
+				id: dataComponent.getId(),
+				name: dataComponent.getName(),
+				description: dataComponent.getDescription(),
+				props: dataComponent.getProps()
+			} : dataComponent;
+			await this.createDataComponent(plainComponent);
+		}
+	}
+	async saveArtifactComponents() {
+		logger.info({ artifactComponents: this.config.artifactComponents }, "artifactComponents and config");
+		const components = resolveGetter(this.config.artifactComponents);
+		if (components) for (const artifactComponent of components) {
+			const plainComponent = artifactComponent && typeof artifactComponent.getId === "function" ? {
+				id: artifactComponent.getId(),
+				name: artifactComponent.getName(),
+				description: artifactComponent.getDescription(),
+				props: artifactComponent.getProps?.() || artifactComponent.props
+			} : artifactComponent;
+			await this.createArtifactComponent(plainComponent);
+		}
+	}
+	async loadDataComponents() {
+		try {
+			const dbDataComponents = [].map((component) => ({
+				id: component.id,
+				name: component.name,
+				description: component.description,
+				props: component.props,
+				createdAt: component.createdAt,
+				updatedAt: component.updatedAt
+			}));
+			const configComponents = resolveGetter(this.config.dataComponents) || [];
+			const normalizedConfigComponents = configComponents.map((comp) => {
+				if (comp && typeof comp.getId === "function") return {
+					id: comp.getId(),
+					name: comp.getName(),
+					description: comp.getDescription(),
+					props: comp.getProps()
+				};
+				return comp;
+			});
+			const uniqueComponents = [...dbDataComponents, ...normalizedConfigComponents].reduce((acc, component) => {
+				const componentId = typeof component.getId === "function" ? component.getId() : component.id;
+				const existingIndex = acc.findIndex((c) => {
+					return (typeof c.getId === "function" ? c.getId() : c.id) === componentId;
+				});
+				if (existingIndex >= 0) acc[existingIndex] = component;
+				else acc.push(component);
+				return acc;
+			}, []);
+			this.config.dataComponents = () => uniqueComponents;
+			logger.info({
+				subAgentId: this.getId(),
+				dbComponentCount: dbDataComponents.length,
+				configComponentCount: configComponents.length,
+				totalComponentCount: uniqueComponents.length
+			}, "Loaded and merged data components");
+		} catch (error) {
+			logger.error({
+				subAgentId: this.getId(),
+				error: error instanceof Error ? error.message : "Unknown error"
+			}, "Failed to load data components from database");
+		}
+	}
+	async loadArtifactComponents() {
+		try {
+			const dbArtifactComponents = [].map((component) => ({
+				id: component.id,
+				name: component.name,
+				description: component.description,
+				props: component.props,
+				createdAt: component.createdAt,
+				updatedAt: component.updatedAt
+			}));
+			const configComponents = resolveGetter(this.config.artifactComponents) || [];
+			const normalizedConfigComponents = configComponents.map((comp) => {
+				if (comp && typeof comp.getId === "function") return {
+					id: comp.getId(),
+					name: comp.getName(),
+					description: comp.getDescription(),
+					props: comp.getProps?.() || comp.props
+				};
+				return comp;
+			});
+			const uniqueComponents = [...dbArtifactComponents, ...normalizedConfigComponents].reduce((acc, component) => {
+				const componentId = typeof component.getId === "function" ? component.getId() : component.id;
+				const existingIndex = acc.findIndex((c) => {
+					return (typeof c.getId === "function" ? c.getId() : c.id) === componentId;
+				});
+				if (existingIndex >= 0) acc[existingIndex] = component;
+				else acc.push(component);
+				return acc;
+			}, []);
+			this.config.artifactComponents = () => uniqueComponents;
+			logger.info({
+				subAgentId: this.getId(),
+				dbComponentCount: dbArtifactComponents.length,
+				configComponentCount: configComponents.length,
+				totalComponentCount: uniqueComponents.length
+			}, "Loaded and merged artifact components");
+		} catch (error) {
+			logger.error({
+				subAgentId: this.getId(),
+				error: error instanceof Error ? error.message : "Unknown error"
+			}, "Failed to load artifact components from database");
+		}
+	}
+	async createFunctionTool(toolId, functionTool) {
+		try {
+			const functionData = functionTool.serializeFunction();
+			const toolData = functionTool.serializeTool();
+			const functionUrl = `${this.baseURL}/tenants/${this.tenantId}/crud/projects/${this.projectId}/functions`;
+			logger.info({
+				agentId: this.getId(),
+				toolId,
+				functionUrl
+			}, "Attempting to create global function");
+			const functionResponse = await fetch(functionUrl, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					id: functionData.id,
+					inputSchema: functionData.inputSchema,
+					executeCode: functionData.executeCode,
+					dependencies: functionData.dependencies
+				})
+			});
+			logger.info({
+				agentId: this.getId(),
+				toolId,
+				functionStatus: functionResponse.status,
+				functionStatusText: functionResponse.statusText
+			}, "Function creation response received");
+			if (!functionResponse.ok) {
+				const errorText = await functionResponse.text();
+				logger.error({
+					agentId: this.getId(),
+					toolId,
+					functionStatus: functionResponse.status,
+					functionStatusText: functionResponse.statusText,
+					errorText
+				}, "Function creation failed");
+				throw new Error(`Failed to create function: ${functionResponse.status} ${errorText}`);
+			}
+			const toolUrl = `${this.baseURL}/tenants/${this.tenantId}/crud/projects/${this.projectId}/tools`;
+			logger.info({
+				agentId: this.getId(),
+				toolId,
+				toolUrl
+			}, "Attempting to create function tool");
+			const toolResponse = await fetch(toolUrl, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					id: toolData.id,
+					name: toolData.name,
+					description: toolData.description,
+					functionId: toolData.functionId,
+					config: { type: "function" }
+				})
+			});
+			logger.info({
+				agentId: this.getId(),
+				toolId,
+				toolStatus: toolResponse.status,
+				toolStatusText: toolResponse.statusText
+			}, "Tool creation response received");
+			if (!toolResponse.ok) {
+				const errorText = await toolResponse.text();
+				logger.error({
+					agentId: this.getId(),
+					toolId,
+					toolStatus: toolResponse.status,
+					toolStatusText: toolResponse.statusText,
+					errorText
+				}, "Tool creation failed");
+				throw new Error(`Failed to create tool: ${toolResponse.status} ${errorText}`);
+			}
+			await this.createAgentToolRelation(toolData.id);
+			logger.info({
+				agentId: this.getId(),
+				functionId: functionData.id,
+				toolId: toolData.id
+			}, "Function and tool created successfully");
+		} catch (error) {
+			logger.error({
+				agentId: this.getId(),
+				toolId,
+				error: error instanceof Error ? error.message : "Unknown error",
+				stack: error instanceof Error ? error.stack : void 0
+			}, "Failed to create function tool");
+			throw error;
+		}
+	}
+	async createTool(toolId, toolConfig) {
+		try {
+			if (toolConfig instanceof FunctionTool) {
+				await this.createFunctionTool(toolId, toolConfig);
+				return;
+			}
+			if (toolConfig.type === "function") {
+				logger.info({
+					subAgentId: this.getId(),
+					toolId
+				}, "Skipping function tool creation - will be handled at runtime");
+				return;
+			}
+			let tool;
+			let selectedTools;
+			let headers;
+			let toolPolicies;
+			try {
+				const normalizedTool = normalizeAgentCanUseType(toolConfig, toolId);
+				tool = normalizedTool.tool;
+				selectedTools = normalizedTool.selectedTools;
+				headers = normalizedTool.headers;
+				toolPolicies = normalizedTool.toolPolicies;
+				tool.setContext(this.tenantId, this.projectId);
+				await tool.init();
+			} catch (_) {
+				tool = new Tool({
+					id: toolId,
+					name: toolConfig.name || toolId,
+					description: toolConfig.description || `MCP tool: ${toolId}`,
+					serverUrl: toolConfig.config?.serverUrl || toolConfig.serverUrl || "http://localhost:3000",
+					activeTools: toolConfig.config?.mcp?.activeTools,
+					credential: toolConfig.credential
+				});
+				tool.setContext(this.tenantId, this.projectId);
+				await tool.init();
+			}
+			await this.createAgentToolRelation(tool.getId(), selectedTools, headers, toolPolicies);
+			logger.info({
+				subAgentId: this.getId(),
+				toolId: tool.getId()
+			}, "Tool created and linked to agent");
+		} catch (error) {
+			logger.error({
+				subAgentId: this.getId(),
+				toolId,
+				error: error instanceof Error ? error.message : "Unknown error"
+			}, "Failed to create tool");
+			throw error;
+		}
+	}
+	async createDataComponent(dataComponent) {
+		try {
+			const dc = new DataComponent({
+				id: dataComponent.id,
+				name: dataComponent.name,
+				description: dataComponent.description,
+				props: dataComponent.props,
+				render: dataComponent.render
+			});
+			dc.setContext(this.tenantId, this.projectId);
+			await dc.init();
+			await this.createAgentDataComponentRelation(dc.getId());
+			logger.info({
+				subAgentId: this.getId(),
+				dataComponentId: dc.getId()
+			}, "DataComponent created and linked to agent");
+		} catch (error) {
+			logger.error({
+				subAgentId: this.getId(),
+				dataComponentName: dataComponent.name,
+				error: error instanceof Error ? error.message : "Unknown error"
+			}, "Failed to create data component");
+			throw error;
+		}
+	}
+	async createArtifactComponent(artifactComponent) {
+		try {
+			const ac = new ArtifactComponent({
+				id: artifactComponent.id,
+				name: artifactComponent.name,
+				description: artifactComponent.description,
+				props: artifactComponent.props
+			});
+			ac.setContext(this.tenantId, this.projectId);
+			await ac.init();
+			await this.createAgentArtifactComponentRelation(ac.getId());
+			logger.info({
+				subAgentId: this.getId(),
+				artifactComponentId: ac.getId()
+			}, "ArtifactComponent created and linked to agent");
+		} catch (error) {
+			logger.error({
+				subAgentId: this.getId(),
+				artifactComponentName: artifactComponent.name,
+				error: error instanceof Error ? error.message : "Unknown error"
+			}, "Failed to create artifact component");
+			throw error;
+		}
+	}
+	async createAgentDataComponentRelation(dataComponentId) {
+		const relationResponse = await fetch(`${this.baseURL}/tenants/${this.tenantId}/agent-data-components`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				id: `${this.getId()}-dc-${dataComponentId}`,
+				tenantId: this.tenantId,
+				subAgentId: this.getId(),
+				dataComponentId
+			})
+		});
+		if (!relationResponse.ok) throw new Error(`Failed to create agent-dataComponent relation: ${relationResponse.status} ${relationResponse.statusText}`);
+		logger.info({
+			subAgentId: this.getId(),
+			dataComponentId
+		}, "Created agent-dataComponent relation");
+	}
+	async createAgentArtifactComponentRelation(artifactComponentId) {
+		const relationResponse = await fetch(`${this.baseURL}/tenants/${this.tenantId}/agent-artifact-components`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				id: crypto.randomUUID(),
+				tenantId: this.tenantId,
+				subAgentId: this.getId(),
+				artifactComponentId
+			})
+		});
+		if (!relationResponse.ok) throw new Error(`Failed to create agent-artifactComponent relation: ${relationResponse.status} ${relationResponse.statusText}`);
+		logger.info({
+			subAgentId: this.getId(),
+			artifactComponentId
+		}, "Created agent-artifactComponent relation");
+	}
+	async createAgentToolRelation(toolId, selectedTools, headers, toolPolicies) {
+		const relationData = {
+			id: `${this.getId()}-tool-${toolId}`,
+			tenantId: this.tenantId,
+			projectId: this.projectId,
+			subAgentId: this.getId(),
+			toolId
+		};
+		if (selectedTools !== void 0) relationData.selectedTools = selectedTools;
+		if (headers !== void 0) relationData.headers = headers;
+		if (toolPolicies !== void 0 && Object.keys(toolPolicies).length > 0) relationData.toolPolicies = toolPolicies;
+		const relationResponse = await fetch(`${this.baseURL}/tenants/${this.tenantId}/projects/${this.projectId}/agent-tool-relations`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(relationData)
+		});
+		if (!relationResponse.ok) {
+			const errorBody = await relationResponse.text().catch(() => "Unknown error");
+			throw new Error(`Failed to create agent-tool relation: ${relationResponse.status} - ${errorBody}`);
+		}
+	}
+};
+function agent(config) {
+	return new SubAgent(config);
+}
+
+//#endregion
+export { SubAgent, agent };