@inkeep/agents-sdk 0.39.4 → 0.40.0

package/dist/index.cjs

@@ -1,4147 +0,0 @@
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") {
-		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-			key = keys[i];
-			if (!__hasOwnProp.call(to, key) && key !== except) {
-				__defProp(to, key, {
-					get: ((k) => from[k]).bind(null, key),
-					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-				});
-			}
-		}
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-let __inkeep_agents_core = require("@inkeep/agents-core");
-let __inkeep_agents_core_utils_schema_conversion = require("@inkeep/agents-core/utils/schema-conversion");
-let node_fs = require("node:fs");
-node_fs = __toESM(node_fs);
-let node_module = require("node:module");
-let node_path = require("node:path");
-node_path = __toESM(node_path);
-let __yarnpkg_lockfile = require("@yarnpkg/lockfile");
-__yarnpkg_lockfile = __toESM(__yarnpkg_lockfile);
-let js_yaml = require("js-yaml");
-js_yaml = __toESM(js_yaml);
-let typescript = require("typescript");
-typescript = __toESM(typescript);
-let zod = require("zod");
-
-//#region src/utils/generateIdFromName.ts
-/**
-* Generates a kebab-case ID from a name string
-* @param name - The name to convert
-* @returns A kebab-case ID
-*/
-function generateIdFromName(name) {
-	return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-}
-
-//#endregion
-//#region src/artifact-component.ts
-const logger$12 = (0, __inkeep_agents_core.getLogger)("artifactComponent");
-var ArtifactComponent = class {
-	config;
-	baseURL;
-	tenantId;
-	projectId;
-	initialized = false;
-	id;
-	constructor(config) {
-		this.id = config.id || generateIdFromName(config.name);
-		let processedProps;
-		if (config.props && (0, __inkeep_agents_core_utils_schema_conversion.isZodSchema)(config.props)) processedProps = (0, __inkeep_agents_core_utils_schema_conversion.convertZodToJsonSchemaWithPreview)(config.props);
-		else processedProps = config.props;
-		this.config = {
-			...config,
-			id: this.id,
-			props: processedProps
-		};
-		this.baseURL = process.env.INKEEP_API_URL || "http://localhost:3002";
-		this.tenantId = "default";
-		this.projectId = "default";
-		logger$12.info({
-			artifactComponentId: this.getId(),
-			artifactComponentName: config.name
-		}, "ArtifactComponent constructor initialized");
-	}
-	setContext(tenantId, projectId, baseURL) {
-		this.tenantId = tenantId;
-		this.projectId = projectId;
-		if (baseURL) this.baseURL = baseURL;
-	}
-	getId() {
-		return this.id;
-	}
-	getName() {
-		return this.config.name;
-	}
-	getDescription() {
-		return this.config.description || "";
-	}
-	getProps() {
-		return this.config.props;
-	}
-	async init() {
-		if (this.initialized) return;
-		try {
-			await this.upsertArtifactComponent();
-			logger$12.info({ artifactComponentId: this.getId() }, "ArtifactComponent initialized successfully");
-			this.initialized = true;
-		} catch (error) {
-			logger$12.error({
-				artifactComponentId: this.getId(),
-				error: error instanceof Error ? error.message : "Unknown error"
-			}, "Failed to initialize artifact component");
-			throw error;
-		}
-	}
-	async upsertArtifactComponent() {
-		const artifactComponentData = {
-			id: this.getId(),
-			name: this.config.name,
-			description: this.config.description,
-			props: this.config.props
-		};
-		logger$12.info({ artifactComponentData }, "artifactComponentData for create/update");
-		const updateResponse = await fetch(`${this.baseURL}/tenants/${this.tenantId}/projects/${this.projectId}/artifact-components/${this.getId()}`, {
-			method: "PUT",
-			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify(artifactComponentData)
-		});
-		logger$12.info({
-			status: updateResponse.status,
-			artifactComponentId: this.getId()
-		}, "artifact component updateResponse");
-		if (updateResponse.ok) {
-			logger$12.info({ artifactComponentId: this.getId() }, "ArtifactComponent updated successfully");
-			return;
-		}
-		if (updateResponse.status === 404) {
-			logger$12.info({ artifactComponentId: this.getId() }, "ArtifactComponent not found, creating new artifact component");
-			const createResponse = await fetch(`${this.baseURL}/tenants/${this.tenantId}/projects/${this.projectId}/artifact-components`, {
-				method: "POST",
-				headers: { "Content-Type": "application/json" },
-				body: JSON.stringify(artifactComponentData)
-			});
-			if (!createResponse.ok) {
-				const errorText$1 = await createResponse.text().catch(() => "Unknown error");
-				throw new Error(`Failed to create artifact component: ${createResponse.status} ${createResponse.statusText} - ${errorText$1}`);
-			}
-			logger$12.info({ artifactComponentId: this.getId() }, "ArtifactComponent created successfully");
-			return;
-		}
-		const errorText = await updateResponse.text().catch(() => "Unknown error");
-		throw new Error(`Failed to update artifact component: ${updateResponse.status} ${updateResponse.statusText} - ${errorText}`);
-	}
-};
-
-//#endregion
-//#region src/projectFullClient.ts
-/**
-* Client-side functions for interacting with the Full Project API
-* These functions make HTTP requests to the server instead of direct database calls
-*/
-const logger$11 = (0, __inkeep_agents_core.getLogger)("projectFullClient");
-/**
-* Create a full project via HTTP API
-*/
-async function createFullProjectViaAPI(tenantId, apiUrl, projectData, apiKey) {
-	logger$11.info({
-		tenantId,
-		projectId: projectData.id,
-		apiUrl
-	}, "Creating full project via API");
-	const url = `${apiUrl}/tenants/${tenantId}/project-full`;
-	const headers = {};
-	if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
-	let response;
-	try {
-		response = await (0, __inkeep_agents_core.apiFetch)(url, {
-			method: "POST",
-			headers,
-			body: JSON.stringify(projectData)
-		});
-	} catch (fetchError) {
-		logger$11.error({
-			error: fetchError instanceof Error ? fetchError.message : "Unknown fetch error",
-			url,
-			tenantId,
-			projectId: projectData.id
-		}, "Fetch request failed");
-		throw fetchError;
-	}
-	if (!response.ok) {
-		const errorMessage = parseError(await response.text()) ?? `Failed to create project: ${response.status} ${response.statusText}`;
-		logger$11.error({
-			status: response.status,
-			error: errorMessage
-		}, "Failed to create project via API");
-		throw new Error(errorMessage);
-	}
-	const result = await response.json();
-	logger$11.info({ projectId: projectData.id }, "Successfully created project via API");
-	return result.data;
-}
-/**
-* Update a full project via HTTP API (upsert behavior)
-*/
-async function updateFullProjectViaAPI(tenantId, apiUrl, projectId, projectData, apiKey) {
-	logger$11.info({
-		tenantId,
-		projectId,
-		apiUrl
-	}, "Updating full project via API");
-	const url = `${apiUrl}/tenants/${tenantId}/project-full/${projectId}`;
-	const headers = {};
-	if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
-	let response;
-	try {
-		response = await (0, __inkeep_agents_core.apiFetch)(url, {
-			method: "PUT",
-			headers,
-			body: JSON.stringify(projectData)
-		});
-	} catch (fetchError) {
-		logger$11.error({
-			error: fetchError instanceof Error ? fetchError.message : "Unknown fetch error",
-			url,
-			tenantId,
-			projectId
-		}, "Fetch request failed");
-		throw fetchError;
-	}
-	if (!response.ok) {
-		const errorMessage = parseError(await response.text()) ?? `Failed to update project: ${response.status} ${response.statusText}`;
-		logger$11.error({
-			status: response.status,
-			error: errorMessage
-		}, "Failed to update project via API");
-		throw new Error(errorMessage);
-	}
-	const result = await response.json();
-	logger$11.info({ projectId }, "Successfully updated project via API");
-	return result.data;
-}
-/**
-* Get a full project via HTTP API
-*/
-async function getFullProjectViaAPI(tenantId, apiUrl, projectId, apiKey) {
-	logger$11.info({
-		tenantId,
-		projectId,
-		apiUrl
-	}, "Getting full project via API");
-	const url = `${apiUrl}/tenants/${tenantId}/project-full/${projectId}`;
-	const headers = {};
-	if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
-	const response = await (0, __inkeep_agents_core.apiFetch)(url, {
-		method: "GET",
-		headers
-	});
-	if (!response.ok) {
-		if (response.status === 404) {
-			logger$11.info({ projectId }, "Project not found");
-			return null;
-		}
-		const errorMessage = parseError(await response.text()) ?? `Failed to get project: ${response.status} ${response.statusText}`;
-		logger$11.error({
-			status: response.status,
-			error: errorMessage
-		}, "Failed to get project via API");
-		throw new Error(errorMessage);
-	}
-	const result = await response.json();
-	logger$11.info({ projectId }, "Successfully retrieved project via API");
-	return result.data;
-}
-/**
-* Delete a full project via HTTP API
-*/
-async function deleteFullProjectViaAPI(tenantId, apiUrl, projectId, apiKey) {
-	logger$11.info({
-		tenantId,
-		projectId,
-		apiUrl
-	}, "Deleting full project via API");
-	const url = `${apiUrl}/tenants/${tenantId}/project-full/${projectId}`;
-	const headers = {};
-	if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
-	const response = await (0, __inkeep_agents_core.apiFetch)(url, {
-		method: "DELETE",
-		headers
-	});
-	if (!response.ok) {
-		const errorMessage = parseError(await response.text()) ?? `Failed to delete project: ${response.status} ${response.statusText}`;
-		logger$11.error({
-			status: response.status,
-			error: errorMessage
-		}, "Failed to delete project via API");
-		throw new Error(errorMessage);
-	}
-	logger$11.info({ projectId }, "Successfully deleted project via API");
-}
-function parseError(errorText) {
-	let result;
-	try {
-		const errorJson = JSON.parse(errorText);
-		if (errorJson.error) {
-			const { error } = errorJson;
-			result = error?.message ?? error;
-		}
-	} catch {
-		if (errorText) result = errorText;
-	}
-	return result;
-}
-
-//#endregion
-//#region src/agentFullClient.ts
-const logger$10 = (0, __inkeep_agents_core.getLogger)("agentFullClient");
-/**
-* Update a full agent via HTTP API (upsert behavior)
-*/
-async function updateFullAgentViaAPI(tenantId, projectId, apiUrl, agentId, agentData) {
-	logger$10.info({
-		tenantId,
-		projectId,
-		agentId,
-		apiUrl
-	}, "Updating full agent via API");
-	const url = `${apiUrl}/tenants/${tenantId}/projects/${projectId}/agent/${agentId}`;
-	const response = await fetch(url, {
-		method: "PUT",
-		headers: { "Content-Type": "application/json" },
-		body: JSON.stringify(agentData)
-	});
-	if (!response.ok) {
-		const errorMessage = parseError(await response.text()) ?? `Failed to update agent: ${response.status} ${response.statusText}`;
-		logger$10.error({
-			status: response.status,
-			error: errorMessage
-		}, "Failed to update agent via API");
-		throw new Error(errorMessage);
-	}
-	const result = await response.json();
-	logger$10.info({ agentId }, "Successfully updated agent via API");
-	return result.data;
-}
-
-//#endregion
-//#region src/utils/getFunctionToolDeps.ts
-const logger$9 = (0, __inkeep_agents_core.getLogger)("function-tool");
-const getFunctionToolDeps = (name, code) => {
-	const { dependencies, warnings } = buildToolManifestFromCodeTS(code);
-	if (warnings.length > 0) logger$9.warn({ warnings }, `FunctionTool dependencies warnings for ${name}`);
-	return dependencies;
-};
-const NODE_BUILTINS = new Set(node_module.builtinModules.concat(node_module.builtinModules.map((m) => `node:${m}`)));
-const isExternal = (spec) => !spec.startsWith(".") && !spec.startsWith("/") && !NODE_BUILTINS.has(spec);
-const collapseSubpath = (spec) => {
-	if (spec.startsWith("@")) {
-		const [scope, name] = spec.split("/");
-		return `${scope}/${name ?? ""}`;
-	}
-	return spec.split("/")[0];
-};
-const readJSON = (p) => JSON.parse(node_fs.default.readFileSync(p, "utf8"));
-const findUp = (start, file) => {
-	let dir = node_path.default.resolve(start);
-	if (node_fs.default.existsSync(dir) && node_fs.default.statSync(dir).isFile()) dir = node_path.default.dirname(dir);
-	for (;;) {
-		const candidate = node_path.default.join(dir, file);
-		if (node_fs.default.existsSync(candidate)) return candidate;
-		const parent = node_path.default.dirname(dir);
-		if (parent === dir) return null;
-		dir = parent;
-	}
-};
-function collectDepsFromCodeTS(code) {
-	const info = typescript.default.preProcessFile(code, true, true);
-	const add = /* @__PURE__ */ new Set();
-	const push = (spec) => {
-		if (isExternal(spec)) add.add(collapseSubpath(spec));
-	};
-	for (const f of info.importedFiles) {
-		const spec = f.fileName;
-		if (spec) push(spec);
-	}
-	const requireLike = /(?:require|import)\s*\(\s*(['"])([^'"]+)\1\s*\)/g;
-	let m;
-	while (m = requireLike.exec(code)) push(m[2]);
-	return add;
-}
-function resolveInstalledVersion(pkg, projectRoot) {
-	const pnpmLock = findUp(projectRoot, "pnpm-lock.yaml");
-	if (pnpmLock) {
-		const pkgs = js_yaml.load(node_fs.default.readFileSync(pnpmLock, "utf8"))?.packages ?? {};
-		for (const key of Object.keys(pkgs)) if (key.startsWith(`${pkg}@`)) {
-			const ver = key.slice(key.indexOf("@") + 1);
-			if (ver) return { exact: String(ver) };
-		}
-	}
-	const npmLock = findUp(projectRoot, "package-lock.json");
-	if (npmLock) {
-		const lock = readJSON(npmLock);
-		if (lock.packages?.[`node_modules/${pkg}`]?.version) return { exact: String(lock.packages[`node_modules/${pkg}`].version) };
-		if (lock.dependencies?.[pkg]?.version) return { exact: String(lock.dependencies[pkg].version) };
-	}
-	const yarnLock = findUp(projectRoot, "yarn.lock");
-	if (yarnLock) {
-		const parsed = __yarnpkg_lockfile.parse(node_fs.default.readFileSync(yarnLock, "utf8"));
-		if (parsed.type === "success") {
-			for (const [key, val] of Object.entries(parsed.object)) if (key === pkg || key.startsWith(`${pkg}@`)) {
-				const ver = val.version;
-				if (ver) return { exact: String(ver) };
-			}
-		}
-	}
-	const host = {
-		fileExists: node_fs.default.existsSync,
-		readFile: (p) => node_fs.default.readFileSync(p, "utf8"),
-		realpath: (p) => node_fs.default.realpathSync.native?.(p) ?? node_fs.default.realpathSync(p),
-		directoryExists: (d) => {
-			try {
-				return node_fs.default.statSync(d).isDirectory();
-			} catch {
-				return false;
-			}
-		},
-		getCurrentDirectory: () => projectRoot,
-		getDirectories: (d) => node_fs.default.readdirSync(d, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name)
-	};
-	const pkgJsonPath = typescript.default.resolveModuleName(`${pkg}/package.json`, node_path.default.join(projectRoot, "__fake.ts"), {}, host, typescript.default.ModuleKind.NodeNext)?.resolvedModule?.resolvedFileName ?? findUp(node_path.default.join(projectRoot, "node_modules", pkg), "package.json");
-	if (pkgJsonPath && node_fs.default.existsSync(pkgJsonPath)) try {
-		const version = readJSON(pkgJsonPath).version;
-		if (version) return { exact: String(version) };
-	} catch {}
-	const hostPkg = findUp(projectRoot, "package.json");
-	if (hostPkg) {
-		const hostJson = readJSON(hostPkg);
-		const range = hostJson.dependencies?.[pkg] ?? hostJson.devDependencies?.[pkg] ?? hostJson.optionalDependencies?.[pkg];
-		if (range) return {
-			range: String(range),
-			unresolved: true
-		};
-	}
-	return null;
-}
-function buildToolManifestFromCodeTS(code, projectRoot = process.cwd()) {
-	const deps = collectDepsFromCodeTS(code);
-	const warnings = [];
-	const dependencies = {};
-	for (const pkg of deps) try {
-		const v = resolveInstalledVersion(pkg, projectRoot);
-		if (!v) {
-			warnings.push(`Could not resolve version for "${pkg}"`);
-			continue;
-		}
-		if ("unresolved" in v) {
-			warnings.push(`Using range for "${pkg}" -> ${v.range} (no lockfile / not installed)`);
-			dependencies[pkg] = v.range;
-		} else dependencies[pkg] = v.exact;
-	} catch {
-		dependencies[pkg] = false;
-	}
-	return {
-		dependencies,
-		warnings
-	};
-}
-
-//#endregion
-//#region src/function-tool.ts
-const logger$8 = (0, __inkeep_agents_core.getLogger)("function-tool");
-var FunctionTool = class {
-	config;
-	id;
-	constructor(config) {
-		this.config = config;
-		this.id = generateIdFromName(config.name);
-		if (!config.dependencies) {
-			const executeCode = typeof config.execute === "string" ? config.execute : config.execute.toString();
-			const deps = getFunctionToolDeps(config.name, executeCode);
-			for (const dep in deps) if (deps[dep] === false) {
-				delete deps[dep];
-				throw new Error(`Dependency \x1b[1;32m${dep}\x1b[0m used in function tool \x1b[1;32m${config.name}\x1b[0m is neither installed nor in dependencies object.`);
-			}
-			this.config.dependencies = deps;
-		}
-		logger$8.info({
-			id: this.id,
-			name: config.name
-		}, "FunctionTool constructor initialized");
-	}
-	getId() {
-		return this.id;
-	}
-	getName() {
-		return this.config.name;
-	}
-	getDescription() {
-		return this.config.description || "";
-	}
-	getInputSchema() {
-		return this.config.inputSchema;
-	}
-	getDependencies() {
-		return this.config.dependencies || {};
-	}
-	getExecuteFunction() {
-		if (typeof this.config.execute === "string") throw new Error("Cannot get execute function from string-based function tool. Use serializeFunction() instead.");
-		return this.config.execute;
-	}
-	serializeFunction() {
-		const executeCode = typeof this.config.execute === "string" ? this.config.execute : this.config.execute.toString();
-		return {
-			id: this.id,
-			inputSchema: this.config.inputSchema,
-			executeCode,
-			dependencies: this.config.dependencies || {}
-		};
-	}
-	serializeTool() {
-		return {
-			id: this.id,
-			name: this.config.name,
-			description: this.config.description,
-			functionId: this.id
-		};
-	}
-};
-
-//#endregion
-//#region src/agent.ts
-const logger$7 = (0, __inkeep_agents_core.getLogger)("agent");
-function resolveGetter$1(value) {
-	if (typeof value === "function") return value();
-	return value;
-}
-var Agent = class {
-	subAgents = [];
-	agentMap = /* @__PURE__ */ new Map();
-	defaultSubAgent;
-	baseURL;
-	tenantId;
-	projectId;
-	agentId;
-	agentName;
-	agentDescription;
-	initialized = false;
-	contextConfig;
-	credentials;
-	models;
-	statusUpdateSettings;
-	prompt;
-	stopWhen;
-	constructor(config) {
-		this.defaultSubAgent = config.defaultSubAgent;
-		this.tenantId = "default";
-		this.projectId = "default";
-		this.agentId = config.id;
-		this.agentName = config.name || this.agentId;
-		this.agentDescription = config.description;
-		this.baseURL = process.env.INKEEP_API_URL || "http://localhost:3002";
-		this.contextConfig = config.contextConfig;
-		this.credentials = resolveGetter$1(config.credentials);
-		this.models = config.models;
-		this.statusUpdateSettings = config.statusUpdates;
-		this.prompt = config.prompt;
-		this.stopWhen = config.stopWhen ? { transferCountIs: config.stopWhen.transferCountIs } : void 0;
-		this.subAgents = resolveGetter$1(config.subAgents) || [];
-		this.agentMap = new Map(this.subAgents.map((agent$1) => [agent$1.getId(), agent$1]));
-		if (this.defaultSubAgent) {
-			if (!this.subAgents.some((agent$1) => agent$1.getId() === this.defaultSubAgent?.getId())) this.subAgents.push(this.defaultSubAgent);
-			this.agentMap.set(this.defaultSubAgent.getId(), this.defaultSubAgent);
-		}
-		if (this.models) this.propagateImmediateModelSettings();
-		logger$7.info({
-			agentId: this.agentId,
-			tenantId: this.tenantId,
-			agentCount: this.subAgents.length,
-			defaultSubAgent: this.defaultSubAgent?.getName()
-		}, "Agent created");
-	}
-	/**
-	* Set or update the configuration (tenantId, projectId and apiUrl)
-	* This is used by the CLI to inject configuration from inkeep.config.ts
-	*/
-	setConfig(tenantId, projectId, apiUrl) {
-		if (this.initialized) throw new Error("Cannot set config after agent has been initialized");
-		this.tenantId = tenantId;
-		this.projectId = projectId;
-		this.baseURL = apiUrl;
-		for (const subAgent$1 of this.subAgents) {
-			if (subAgent$1.setContext) subAgent$1.setContext(tenantId, projectId, apiUrl);
-			const tools = subAgent$1.getTools();
-			for (const [_, toolInstance] of Object.entries(tools)) if (toolInstance && typeof toolInstance === "object") {
-				if ("setContext" in toolInstance && typeof toolInstance.setContext === "function") toolInstance.setContext(tenantId, projectId, apiUrl);
-			}
-		}
-		if (this.contextConfig?.setContext) this.contextConfig.setContext(tenantId, projectId, this.agentId, this.baseURL);
-		logger$7.info({
-			agentId: this.agentId,
-			tenantId: this.tenantId,
-			projectId: this.projectId,
-			apiUrl: this.baseURL
-		}, "Agent configuration updated");
-	}
-	/**
-	* Convert the Agent to FullAgentDefinition format for the new agent endpoint
-	*/
-	async toFullAgentDefinition() {
-		const subAgentsObject = {};
-		const externalAgentsObject = {};
-		const functionToolsObject = {};
-		const functionsObject = {};
-		for (const subAgent$1 of this.subAgents) {
-			const transfers = subAgent$1.getTransfers();
-			const delegates = subAgent$1.getDelegates();
-			const tools = [];
-			const selectedToolsMapping = {};
-			const headersMapping = {};
-			const toolPoliciesMapping = {};
-			const subAgentTools = subAgent$1.getTools();
-			for (const [_toolName, toolInstance] of Object.entries(subAgentTools)) {
-				const toolId = toolInstance.getId();
-				if (toolInstance.selectedTools) selectedToolsMapping[toolId] = toolInstance.selectedTools;
-				if (toolInstance.headers) headersMapping[toolId] = toolInstance.headers;
-				if (toolInstance.toolPolicies) toolPoliciesMapping[toolId] = toolInstance.toolPolicies;
-				tools.push(toolId);
-				if (toolInstance.constructor.name === "FunctionTool" && toolInstance instanceof FunctionTool) {
-					if (!functionsObject[toolId]) functionsObject[toolId] = toolInstance.serializeFunction();
-					if (!functionToolsObject[toolId]) {
-						const toolData = toolInstance.serializeTool();
-						functionToolsObject[toolId] = {
-							id: toolData.id,
-							name: toolData.name,
-							description: toolData.description,
-							functionId: toolData.functionId,
-							agentId: this.agentId
-						};
-					}
-				}
-			}
-			const subAgentExternalAgents = subAgent$1.getExternalAgentDelegates();
-			for (const externalAgentDelegate of subAgentExternalAgents) {
-				const externalAgent$1 = externalAgentDelegate.externalAgent;
-				externalAgentsObject[externalAgent$1.getId()] = {
-					id: externalAgent$1.getId(),
-					name: externalAgent$1.getName(),
-					description: externalAgent$1.getDescription(),
-					baseUrl: externalAgent$1.getBaseUrl(),
-					credentialReferenceId: externalAgent$1.getCredentialReferenceId(),
-					type: "external"
-				};
-			}
-			const dataComponents = [];
-			const subAgentDataComponents = subAgent$1.getDataComponents();
-			if (subAgentDataComponents) for (const dataComponent$1 of subAgentDataComponents) {
-				const dataComponentId = dataComponent$1.id || dataComponent$1.name.toLowerCase().replace(/\s+/g, "-");
-				dataComponents.push(dataComponentId);
-			}
-			const artifactComponents = [];
-			const subAgentArtifactComponents = subAgent$1.getArtifactComponents();
-			if (subAgentArtifactComponents) for (const artifactComponent$1 of subAgentArtifactComponents) {
-				const artifactComponentId = artifactComponent$1.id || artifactComponent$1.name.toLowerCase().replace(/\s+/g, "-");
-				artifactComponents.push(artifactComponentId);
-			}
-			const canUse = tools.map((toolId) => ({
-				toolId,
-				toolSelection: selectedToolsMapping[toolId] || null,
-				headers: headersMapping[toolId] || null,
-				toolPolicies: toolPoliciesMapping[toolId] || null
-			}));
-			subAgentsObject[subAgent$1.getId()] = {
-				id: subAgent$1.getId(),
-				name: subAgent$1.getName(),
-				description: subAgent$1.config.description || "",
-				prompt: subAgent$1.getInstructions(),
-				models: subAgent$1.config.models,
-				stopWhen: subAgent$1.config.stopWhen,
-				canTransferTo: transfers.map((h) => h.getId()),
-				canDelegateTo: delegates.map((d) => {
-					if (typeof d === "object" && "externalAgent" in d) return {
-						externalAgentId: d.externalAgent.getId(),
-						...d.headers && { headers: d.headers }
-					};
-					if (typeof d === "object" && "agent" in d) return {
-						agentId: d.agent.getId(),
-						...d.headers && { headers: d.headers }
-					};
-					return d.getId();
-				}),
-				canUse,
-				dataComponents: dataComponents.length > 0 ? dataComponents : void 0,
-				artifactComponents: artifactComponents.length > 0 ? artifactComponents : void 0,
-				type: "internal"
-			};
-		}
-		const processedStatusUpdates = this.statusUpdateSettings ? {
-			...this.statusUpdateSettings,
-			statusComponents: this.statusUpdateSettings.statusComponents?.map((comp) => {
-				if (comp && typeof comp.getType === "function") return {
-					type: comp.getType(),
-					description: comp.getDescription(),
-					detailsSchema: comp.getDetailsSchema()
-				};
-				if (comp && typeof comp === "object" && comp.detailsSchema && (0, __inkeep_agents_core_utils_schema_conversion.isZodSchema)(comp.detailsSchema)) {
-					const jsonSchema = (0, __inkeep_agents_core_utils_schema_conversion.convertZodToJsonSchema)(comp.detailsSchema);
-					return {
-						type: comp.type,
-						description: comp.description,
-						detailsSchema: {
-							type: "object",
-							properties: jsonSchema.properties || {},
-							required: jsonSchema.required || void 0
-						}
-					};
-				}
-				return comp;
-			})
-		} : void 0;
-		const agentToolsObject = {};
-		for (const subAgent$1 of this.subAgents) {
-			const subAgentTools = subAgent$1.getTools();
-			for (const [_toolName, toolInstance] of Object.entries(subAgentTools)) {
-				const toolId = toolInstance.getId();
-				if (toolInstance.constructor.name !== "FunctionTool") {
-					if (!agentToolsObject[toolId]) {
-						if ("config" in toolInstance && "serverUrl" in toolInstance.config) {
-							const mcpTool$1 = toolInstance;
-							agentToolsObject[toolId] = {
-								id: toolId,
-								name: toolInstance.getName(),
-								description: null,
-								config: {
-									type: "mcp",
-									mcp: {
-										server: { url: mcpTool$1.config.serverUrl },
-										transport: mcpTool$1.config.transport,
-										activeTools: mcpTool$1.config.activeTools
-									}
-								},
-								credentialReferenceId: null
-							};
-						}
-					}
-				}
-			}
-		}
-		return {
-			id: this.agentId,
-			name: this.agentName,
-			description: this.agentDescription,
-			defaultSubAgentId: this.defaultSubAgent?.getId() || "",
-			subAgents: subAgentsObject,
-			externalAgents: externalAgentsObject,
-			contextConfig: this.contextConfig?.toObject(),
-			...Object.keys(functionToolsObject).length > 0 && { functionTools: functionToolsObject },
-			...Object.keys(functionsObject).length > 0 && { functions: functionsObject },
-			models: this.models,
-			stopWhen: this.stopWhen,
-			statusUpdates: processedStatusUpdates,
-			prompt: this.prompt,
-			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-		};
-	}
-	/**
-	* Initialize all tools in all agents (especially IPCTools that need MCP server URLs)
-	*/
-	async initializeAllTools() {
-		logger$7.info({ agentId: this.agentId }, "Initializing all tools in agent");
-		const toolInitPromises = [];
-		for (const subAgent$1 of this.subAgents) {
-			const agentTools = subAgent$1.getTools();
-			for (const [toolName, toolInstance] of Object.entries(agentTools)) if (toolInstance && typeof toolInstance === "object") {
-				if (typeof toolInstance.init === "function") toolInitPromises.push((async () => {
-					try {
-						const skipDbRegistration = toolInstance.constructor.name === "IPCTool" || toolInstance.constructor.name === "HostedTool" || toolInstance.constructor.name === "Tool";
-						if (typeof toolInstance.init === "function") if (skipDbRegistration) await toolInstance.init({ skipDatabaseRegistration: true });
-						else await toolInstance.init();
-						logger$7.debug({
-							subAgentId: subAgent$1.getId(),
-							toolName,
-							toolType: toolInstance.constructor.name,
-							skipDbRegistration
-						}, "Tool initialized successfully");
-					} catch (error) {
-						logger$7.error({
-							subAgentId: subAgent$1.getId(),
-							toolName,
-							error: error instanceof Error ? error.message : "Unknown error"
-						}, "Failed to initialize tool");
-						throw error;
-					}
-				})());
-			}
-		}
-		await Promise.all(toolInitPromises);
-		logger$7.info({
-			agentId: this.agentId,
-			toolCount: toolInitPromises.length
-		}, "All tools initialized successfully");
-	}
-	/**
-	* Initialize the agent and all agents in the backend using the new agent endpoint
-	*/
-	async init() {
-		if (this.initialized) {
-			logger$7.info({ agentId: this.agentId }, "Agent already initialized");
-			return;
-		}
-		logger$7.info({
-			agentId: this.agentId,
-			agentCount: this.subAgents.length
-		}, "Initializing agent using new agent endpoint");
-		try {
-			await this.initializeAllTools();
-			await this.applyModelInheritance();
-			const agentDefinition = await this.toFullAgentDefinition();
-			logger$7.info({
-				agentId: this.agentId,
-				mode: "api-client",
-				apiUrl: this.baseURL
-			}, "Using API client to create/update agent");
-			const createdAgent = await updateFullAgentViaAPI(this.tenantId, this.projectId, this.baseURL, this.agentId, agentDefinition);
-			logger$7.info({
-				agentId: this.agentId,
-				agentCount: Object.keys(createdAgent.subAgents || {}).length
-			}, "Agent initialized successfully using agent endpoint");
-			this.initialized = true;
-		} catch (error) {
-			logger$7.error({
-				agentId: this.agentId,
-				error: error instanceof Error ? error.message : "Unknown error"
-			}, "Failed to initialize agent using agent endpoint");
-			throw error;
-		}
-	}
-	/**
-	* Generate a response using the default agent
-	*/
-	async generate(input, options) {
-		await this._init();
-		if (!this.defaultSubAgent) throw new Error("No default agent configured for this agent");
-		logger$7.info({
-			agentId: this.agentId,
-			defaultSubAgent: this.defaultSubAgent.getName(),
-			conversationId: options?.conversationId
-		}, "Generating response with default agent");
-		return await this.executeWithBackend(input, options);
-	}
-	/**
-	* Stream a response using the default agent
-	*/
-	async stream(input, options) {
-		await this._init();
-		if (!this.defaultSubAgent) throw new Error("No default agent configured for this agent");
-		logger$7.info({
-			agentId: this.agentId,
-			defaultSubAgent: this.defaultSubAgent.getName(),
-			conversationId: options?.conversationId
-		}, "Streaming response with default agent");
-		const textStream = async function* (agent$1) {
-			const words = (await agent$1.executeWithBackend(input, options)).split(" ");
-			for (const word of words) yield `${word} `;
-		};
-		return { textStream: textStream(this) };
-	}
-	/**
-	* Alias for stream() method for consistency with naming patterns
-	*/
-	async generateStream(input, options) {
-		return await this.stream(input, options);
-	}
-	/**
-	* Run with a specific agent from the agent
-	*/
-	async runWith(subAgentId, input, options) {
-		await this._init();
-		const agent$1 = this.getSubAgent(subAgentId);
-		if (!agent$1) throw new Error(`Agent '${subAgentId}' not found in agent`);
-		logger$7.info({
-			agentId: this.agentId,
-			subAgentId,
-			conversationId: options?.conversationId
-		}, "Running with specific agent");
-		return {
-			finalOutput: await this.executeWithBackend(input, options),
-			agent: agent$1,
-			turnCount: 1,
-			usage: {
-				inputTokens: 0,
-				outputTokens: 0
-			},
-			metadata: {
-				toolCalls: [],
-				transfers: []
-			}
-		};
-	}
-	/**
-	* Get an agent by name (unified method for all agent types)
-	*/
-	getSubAgent(name) {
-		return this.agentMap.get(name);
-	}
-	/**
-	* Add an agent to the agent
-	*/
-	addSubAgent(agent$1) {
-		this.subAgents.push(agent$1);
-		this.agentMap.set(agent$1.getId(), agent$1);
-		if (this.models) this.propagateModelSettingsToAgent(agent$1);
-		logger$7.info({
-			agentId: this.agentId,
-			subAgentId: agent$1.getId()
-		}, "SubAgent added to agent");
-	}
-	/**
-	* Remove an agent from the agent
-	*/
-	removeSubAgent(id) {
-		const agentToRemove = this.agentMap.get(id);
-		if (agentToRemove) {
-			this.agentMap.delete(agentToRemove.getId());
-			this.subAgents = this.subAgents.filter((agent$1) => agent$1.getId() !== agentToRemove.getId());
-			logger$7.info({
-				agentId: this.agentId,
-				subAgentId: agentToRemove.getId()
-			}, "Agent removed from agent");
-			return true;
-		}
-		return false;
-	}
-	/**
-	* Get all agents in the agent
-	*/
-	getSubAgents() {
-		return this.subAgents;
-	}
-	/**
-	* Get all agent ids (unified method for all agent types)
-	*/
-	getSubAgentIds() {
-		return Array.from(this.agentMap.keys());
-	}
-	/**
-	* Set the default agent
-	*/
-	setDefaultSubAgent(agent$1) {
-		this.defaultSubAgent = agent$1;
-		this.addSubAgent(agent$1);
-		logger$7.info({
-			agentId: this.agentId,
-			defaultSubAgent: agent$1.getId()
-		}, "Default agent updated");
-	}
-	/**
-	* Get the default agent
-	*/
-	getDefaultSubAgent() {
-		return this.defaultSubAgent;
-	}
-	/**
-	* Get the agent ID
-	*/
-	getId() {
-		return this.agentId;
-	}
-	getName() {
-		return this.agentName;
-	}
-	getDescription() {
-		return this.agentDescription;
-	}
-	getTenantId() {
-		return this.tenantId;
-	}
-	/**
-	* Get the agent's model settingsuration
-	*/
-	getModels() {
-		return this.models;
-	}
-	/**
-	* Set the agent's model settingsuration
-	*/
-	setModels(models) {
-		this.models = models;
-	}
-	/**
-	* Get the agent's prompt configuration
-	*/
-	getPrompt() {
-		return this.prompt;
-	}
-	/**
-	* Get the agent's stopWhen configuration
-	*/
-	getStopWhen() {
-		return this.stopWhen || { transferCountIs: 10 };
-	}
-	/**
-	* Get the agent's status updates configuration
-	*/
-	getStatusUpdateSettings() {
-		return this.statusUpdateSettings;
-	}
-	/**
-	* Get the summarizer model from the agent's model settings
-	*/
-	getSummarizerModel() {
-		return this.models?.summarizer;
-	}
-	/**
-	* Get agent statistics
-	*/
-	getStats() {
-		return {
-			agentCount: this.subAgents.length,
-			defaultSubAgent: this.defaultSubAgent?.getName() || null,
-			initialized: this.initialized,
-			agentId: this.agentId,
-			tenantId: this.tenantId
-		};
-	}
-	with(options) {
-		return {
-			agent: this,
-			headers: options.headers
-		};
-	}
-	/**
-	* Validate the agent configuration
-	*/
-	validate() {
-		const errors = [];
-		if (this.subAgents.length === 0) errors.push("Agent must contain at least one agent");
-		if (!this.defaultSubAgent) errors.push("Agent must have a default agent");
-		const names = /* @__PURE__ */ new Set();
-		for (const subAgent$1 of this.subAgents) {
-			const name = subAgent$1.getName();
-			if (names.has(name)) errors.push(`Duplicate agent name: ${name}`);
-			names.add(name);
-		}
-		for (const subAgent$1 of this.subAgents) {
-			const transfers = subAgent$1.getTransfers();
-			for (const transferAgent of transfers) if (!this.agentMap.has(transferAgent.getName())) errors.push(`Agent '${subAgent$1.getName()}' has transfer to '${transferAgent.getName()}' which is not in the agent`);
-			const delegates = subAgent$1.getDelegates();
-			for (const delegateAgent of delegates) if (this.isInternalAgent(delegateAgent)) {
-				if (!this.agentMap.has(delegateAgent.getName())) errors.push(`Agent '${subAgent$1.getName()}' has delegation to '${delegateAgent.getName()}' which is not in the agent`);
-			}
-		}
-		return {
-			valid: errors.length === 0,
-			errors
-		};
-	}
-	async _init() {
-		if (!this.initialized) await this.init();
-	}
-	/**
-	* Type guard to check if an agent is an internal AgentInterface
-	*/
-	isInternalAgent(agent$1) {
-		return "getTransfers" in agent$1 && typeof agent$1.getTransfers === "function";
-	}
-	/**
-	* Get project-level model settingsuration defaults
-	*/
-	async getProjectModelDefaults() {
-		try {
-			return (await getFullProjectViaAPI(this.tenantId, this.projectId, this.baseURL))?.models;
-		} catch (error) {
-			logger$7.warn({
-				tenantId: this.tenantId,
-				projectId: this.projectId,
-				error: error instanceof Error ? error.message : "Unknown error"
-			}, "Failed to get project model defaults");
-			return;
-		}
-	}
-	/**
-	* Get project-level stopWhen configuration defaults
-	*/
-	async getProjectStopWhenDefaults() {
-		try {
-			return (await getFullProjectViaAPI(this.tenantId, this.projectId, this.baseURL))?.stopWhen;
-		} catch (error) {
-			logger$7.warn({
-				tenantId: this.tenantId,
-				projectId: this.projectId,
-				error: error instanceof Error ? error.message : "Unknown error"
-			}, "Failed to get project stopWhen defaults");
-			return;
-		}
-	}
-	/**
-	* Apply model inheritance hierarchy: Project -> Agent -> Agent
-	*/
-	async applyModelInheritance() {
-		const projectModels = await this.getProjectModelDefaults();
-		if (projectModels) {
-			if (!this.models) this.models = {};
-			if (!this.models.base && projectModels.base) this.models.base = projectModels.base;
-			if (!this.models.structuredOutput && projectModels.structuredOutput) this.models.structuredOutput = projectModels.structuredOutput;
-			if (!this.models.summarizer && projectModels.summarizer) this.models.summarizer = projectModels.summarizer;
-		}
-		await this.applyStopWhenInheritance();
-		for (const subAgent$1 of this.subAgents) this.propagateModelSettingsToAgent(subAgent$1);
-	}
-	/**
-	* Apply stopWhen inheritance hierarchy: Project -> Agent -> Agent
-	*/
-	async applyStopWhenInheritance() {
-		const projectStopWhen = await this.getProjectStopWhenDefaults();
-		if (!this.stopWhen) this.stopWhen = {};
-		if (this.stopWhen.transferCountIs === void 0 && projectStopWhen?.transferCountIs !== void 0) this.stopWhen.transferCountIs = projectStopWhen.transferCountIs;
-		if (this.stopWhen.transferCountIs === void 0) this.stopWhen.transferCountIs = 10;
-		if (projectStopWhen?.stepCountIs !== void 0) for (const subAgent$1 of this.subAgents) {
-			if (!subAgent$1.config.stopWhen) subAgent$1.config.stopWhen = {};
-			if (subAgent$1.config.stopWhen.stepCountIs === void 0) subAgent$1.config.stopWhen.stepCountIs = projectStopWhen.stepCountIs;
-		}
-		logger$7.debug({
-			agentId: this.agentId,
-			agentStopWhen: this.stopWhen,
-			projectStopWhen
-		}, "Applied stopWhen inheritance from project to agent");
-	}
-	/**
-	* Propagate agent-level model settings to agents (supporting partial inheritance)
-	*/
-	propagateModelSettingsToAgent(agent$1) {
-		if (this.models) {
-			if (!agent$1.config.models) agent$1.config.models = {};
-			if (!agent$1.config.models.base && this.models.base) agent$1.config.models.base = this.models.base;
-			if (!agent$1.config.models.structuredOutput && this.models.structuredOutput) agent$1.config.models.structuredOutput = this.models.structuredOutput;
-			if (!agent$1.config.models.summarizer && this.models.summarizer) agent$1.config.models.summarizer = this.models.summarizer;
-		}
-	}
-	/**
-	* Immediately propagate agent-level models to all agents during construction
-	*/
-	propagateImmediateModelSettings() {
-		for (const subAgent$1 of this.subAgents) this.propagateModelSettingsToAgent(subAgent$1);
-	}
-	/**
-	* Execute agent using the backend system instead of local runner
-	*/
-	async executeWithBackend(input, options) {
-		const normalizedMessages = this.normalizeMessages(input);
-		const url = `${this.baseURL}/tenants/${this.tenantId}/agent/${this.agentId}/v1/chat/completions`;
-		logger$7.info({ url }, "Executing with backend");
-		const requestBody = {
-			model: "gpt-4o-mini",
-			messages: normalizedMessages.map((msg) => ({
-				role: msg.role,
-				content: msg.content
-			})),
-			...options,
-			...options?.conversationId && { conversationId: options.conversationId },
-			...options?.customBodyParams && { ...options.customBodyParams },
-			stream: false
-		};
-		try {
-			const response = await fetch(url, {
-				method: "POST",
-				headers: {
-					"Content-Type": "application/json",
-					Accept: "application/json"
-				},
-				body: JSON.stringify(requestBody)
-			});
-			if (!response.ok) throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-			const responseText = await response.text();
-			if (responseText.startsWith("data:")) return this.parseStreamingResponse(responseText);
-			const data = JSON.parse(responseText);
-			return data.result || data.choices?.[0]?.message?.content || "";
-		} catch (error) {
-			throw new Error(`Agent execution failed: ${error.message || "Unknown error"}`);
-		}
-	}
-	/**
-	* Parse streaming response in SSE format
-	*/
-	parseStreamingResponse(text) {
-		const lines = text.split("\n");
-		let content = "";
-		for (const line of lines) if (line.startsWith("data: ")) {
-			const dataStr = line.slice(6);
-			if (dataStr === "[DONE]") break;
-			try {
-				const delta = JSON.parse(dataStr).choices?.[0]?.delta?.content;
-				if (delta) content += delta;
-			} catch (_e) {}
-		}
-		return content;
-	}
-	/**
-	* Normalize input messages to the expected format
-	*/
-	normalizeMessages(input) {
-		if (typeof input === "string") return [{
-			role: "user",
-			content: input
-		}];
-		if (Array.isArray(input)) return input.map((msg) => typeof msg === "string" ? {
-			role: "user",
-			content: msg
-		} : msg);
-		return [input];
-	}
-};
-
-//#endregion
-//#region src/data-component.ts
-const logger$6 = (0, __inkeep_agents_core.getLogger)("dataComponent");
-var DataComponent = class {
-	config;
-	baseURL;
-	tenantId;
-	projectId;
-	initialized = false;
-	id;
-	constructor(config) {
-		this.id = config.id || generateIdFromName(config.name);
-		let processedProps;
-		if (config.props && (0, __inkeep_agents_core_utils_schema_conversion.isZodSchema)(config.props)) processedProps = (0, __inkeep_agents_core_utils_schema_conversion.convertZodToJsonSchema)(config.props);
-		else processedProps = config.props;
-		this.config = {
-			...config,
-			id: this.id,
-			props: processedProps,
-			render: config.render || null
-		};
-		this.baseURL = process.env.INKEEP_API_URL || "http://localhost:3002";
-		this.tenantId = "default";
-		this.projectId = "default";
-		logger$6.info({
-			dataComponentId: this.getId(),
-			dataComponentName: config.name
-		}, "DataComponent constructor initialized");
-	}
-	setContext(tenantId, projectId, baseURL) {
-		this.tenantId = tenantId;
-		this.projectId = projectId;
-		if (baseURL) this.baseURL = baseURL;
-	}
-	getId() {
-		return this.id;
-	}
-	getName() {
-		return this.config.name;
-	}
-	getDescription() {
-		return this.config.description || "";
-	}
-	getProps() {
-		return this.config.props;
-	}
-	getRender() {
-		return this.config.render;
-	}
-	async init() {
-		if (this.initialized) return;
-		try {
-			await this.upsertDataComponent();
-			logger$6.info({ dataComponentId: this.getId() }, "DataComponent initialized successfully");
-			this.initialized = true;
-		} catch (error) {
-			logger$6.error({
-				dataComponentId: this.getId(),
-				error: error instanceof Error ? error.message : "Unknown error"
-			}, "Failed to initialize data component");
-			throw error;
-		}
-	}
-	async upsertDataComponent() {
-		const dataComponentData = {
-			id: this.getId(),
-			name: this.config.name,
-			description: this.config.description,
-			props: this.config.props,
-			render: this.config.render
-		};
-		logger$6.info({ dataComponentData }, "dataComponentData for create/update");
-		const updateResponse = await fetch(`${this.baseURL}/tenants/${this.tenantId}/projects/${this.projectId}/data-components/${this.getId()}`, {
-			method: "PUT",
-			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify(dataComponentData)
-		});
-		logger$6.info({
-			status: updateResponse.status,
-			dataComponentId: this.getId()
-		}, "data component updateResponse");
-		if (updateResponse.ok) {
-			logger$6.info({ dataComponentId: this.getId() }, "DataComponent updated successfully");
-			return;
-		}
-		if (updateResponse.status === 404) {
-			logger$6.info({ dataComponentId: this.getId() }, "DataComponent not found, creating new data component");
-			const createResponse = await fetch(`${this.baseURL}/tenants/${this.tenantId}/projects/${this.projectId}/data-components`, {
-				method: "POST",
-				headers: { "Content-Type": "application/json" },
-				body: JSON.stringify(dataComponentData)
-			});
-			if (!createResponse.ok) {
-				const errorText$1 = await createResponse.text().catch(() => "Unknown error");
-				throw new Error(`Failed to create data component: ${createResponse.status} ${createResponse.statusText} - ${errorText$1}`);
-			}
-			logger$6.info({ dataComponentId: this.getId() }, "DataComponent created successfully");
-			return;
-		}
-		const errorText = await updateResponse.text().catch(() => "Unknown error");
-		throw new Error(`Failed to update data component: ${updateResponse.status} ${updateResponse.statusText} - ${errorText}`);
-	}
-};
-
-//#endregion
-//#region src/project.ts
-const logger$5 = (0, __inkeep_agents_core.getLogger)("project");
-/**
-* Project class for managing agent projects
-*
-* Projects are the top-level organizational unit that contains Agents, Sub Agents, and shared configurations.
-* They provide model inheritance and execution limits that cascade down to Agents and Sub Agents.
-*
-* @example
-* ```typescript
-* const myProject = new Project({
-*   id: 'customer-support-project',
-*   name: 'Customer Support System',
-*   description: 'Multi-agent customer support system',
-*   models: {
-*     base: { model: 'gpt-4.1-mini' },
-*     structuredOutput: { model: 'gpt-4.1' }
-*   },
-*   stopWhen: {
-*     transferCountIs: 10,
-*     stepCountIs: 50
-*   }
-* });
-*
-* await myProject.init();
-* ```
-*/
-var Project = class {
-	__type = "project";
-	projectId;
-	projectName;
-	projectDescription;
-	tenantId;
-	baseURL;
-	apiKey;
-	initialized = false;
-	models;
-	stopWhen;
-	agents = [];
-	agentMap = /* @__PURE__ */ new Map();
-	credentialReferences = [];
-	projectTools = [];
-	projectDataComponents = [];
-	projectArtifactComponents = [];
-	projectExternalAgents = [];
-	externalAgentMap = /* @__PURE__ */ new Map();
-	constructor(config) {
-		this.projectId = config.id;
-		this.projectName = config.name;
-		this.projectDescription = config.description;
-		this.tenantId = process.env.INKEEP_TENANT_ID || "default";
-		this.baseURL = process.env.INKEEP_API_URL || "http://localhost:3002";
-		this.models = config.models;
-		this.stopWhen = config.stopWhen;
-		if (config.agents) {
-			this.agents = config.agents();
-			this.agentMap = new Map(this.agents.map((agent$1) => [agent$1.getId(), agent$1]));
-			for (const agent$1 of this.agents) agent$1.setConfig(this.tenantId, this.projectId, this.baseURL);
-		}
-		if (config.tools) this.projectTools = config.tools();
-		if (config.dataComponents) this.projectDataComponents = config.dataComponents();
-		if (config.artifactComponents) this.projectArtifactComponents = config.artifactComponents();
-		if (config.credentialReferences) this.credentialReferences = config.credentialReferences();
-		if (config.externalAgents) {
-			this.projectExternalAgents = config.externalAgents();
-			this.externalAgentMap = new Map(this.projectExternalAgents.map((externalAgent$1) => [externalAgent$1.getId(), externalAgent$1]));
-		}
-		logger$5.info({
-			projectId: this.projectId,
-			tenantId: this.tenantId,
-			agentCount: this.agents.length
-		}, "Project created");
-	}
-	/**
-	* Set or update the configuration (tenantId and apiUrl)
-	* This is used by the CLI to inject configuration from inkeep.config.ts
-	*/
-	setConfig(tenantId, apiUrl, models, apiKey) {
-		if (this.initialized) throw new Error("Cannot set config after project has been initialized");
-		this.tenantId = tenantId;
-		this.baseURL = apiUrl;
-		this.apiKey = apiKey;
-		if (models) this.models = models;
-		for (const agent$1 of this.agents) agent$1.setConfig(tenantId, this.projectId, apiUrl);
-		logger$5.info({
-			projectId: this.projectId,
-			tenantId: this.tenantId,
-			apiUrl: this.baseURL,
-			hasModels: !!this.models,
-			hasApiKey: !!this.apiKey
-		}, "Project configuration updated");
-	}
-	/**
-	* Set credential references for the project
-	* This is used by the CLI to inject environment-specific credentials
-	*/
-	setCredentials(credentials) {
-		this.credentialReferences = Object.values(credentials);
-		logger$5.info({
-			projectId: this.projectId,
-			credentialCount: this.credentialReferences?.length || 0
-		}, "Project credentials updated");
-	}
-	/**
-	* Initialize the project and create/update it in the backend using full project approach
-	*/
-	async init() {
-		if (this.initialized) {
-			logger$5.info({ projectId: this.projectId }, "Project already initialized");
-			return;
-		}
-		logger$5.info({
-			projectId: this.projectId,
-			tenantId: this.tenantId,
-			agentCount: this.agents.length
-		}, "Initializing project using full project endpoint");
-		try {
-			const projectDefinition = await this.toFullProjectDefinition();
-			logger$5.info({
-				projectId: this.projectId,
-				mode: "api-client",
-				apiUrl: this.baseURL
-			}, "Using API client to create/update full project");
-			const createdProject = await updateFullProjectViaAPI(this.tenantId, this.baseURL, this.projectId, projectDefinition, this.apiKey);
-			this.initialized = true;
-			logger$5.info({
-				projectId: this.projectId,
-				tenantId: this.tenantId,
-				agentCount: Object.keys(createdProject.agent || {}).length
-			}, "Project initialized successfully using full project endpoint");
-		} catch (error) {
-			logger$5.error({
-				projectId: this.projectId,
-				error: error instanceof Error ? error.message : "Unknown error"
-			}, "Failed to initialize project using full project endpoint");
-			throw error;
-		}
-	}
-	/**
-	* Get the project ID
-	*/
-	getId() {
-		return this.projectId;
-	}
-	/**
-	* Get the project name
-	*/
-	getName() {
-		return this.projectName;
-	}
-	/**
-	* Get the project description
-	*/
-	getDescription() {
-		return this.projectDescription;
-	}
-	/**
-	* Get the tenant ID
-	*/
-	getTenantId() {
-		return this.tenantId;
-	}
-	/**
-	* Get the project's model configuration
-	*/
-	getModels() {
-		return this.models;
-	}
-	/**
-	* Set the project's model configuration
-	*/
-	setModels(models) {
-		this.models = models;
-	}
-	/**
-	* Get the project's stopWhen configuration
-	*/
-	getStopWhen() {
-		return this.stopWhen;
-	}
-	/**
-	* Set the project's stopWhen configuration
-	*/
-	setStopWhen(stopWhen) {
-		this.stopWhen = stopWhen;
-	}
-	/**
-	* Get credential tracking information
-	*/
-	async getCredentialTracking() {
-		const credentials = (await this.toFullProjectDefinition()).credentialReferences || {};
-		const usage = {};
-		for (const [credId, credData] of Object.entries(credentials)) if (credData.usedBy) usage[credId] = credData.usedBy;
-		return {
-			credentials,
-			usage
-		};
-	}
-	async getFullDefinition() {
-		return await this.toFullProjectDefinition();
-	}
-	/**
-	* Get all agent in the project
-	*/
-	getAgents() {
-		return this.agents;
-	}
-	/**
-	* Get all external agents in the project
-	*/
-	getExternalAgents() {
-		return this.projectExternalAgents;
-	}
-	/**
-	* Get an external agent by ID
-	*/
-	getExternalAgent(id) {
-		return this.externalAgentMap.get(id);
-	}
-	/**
-	* Add an external agent to the project
-	*/
-	addExternalAgent(externalAgent$1) {
-		this.projectExternalAgents.push(externalAgent$1);
-		this.externalAgentMap.set(externalAgent$1.getId(), externalAgent$1);
-	}
-	/**
-	* Remove an external agent from the project
-	*/
-	removeExternalAgent(id) {
-		if (this.externalAgentMap.get(id)) {
-			this.externalAgentMap.delete(id);
-			this.projectExternalAgents = this.projectExternalAgents.filter((externalAgent$1) => externalAgent$1.getId() !== id);
-			logger$5.info({
-				projectId: this.projectId,
-				externalAgentId: id
-			}, "External agent removed from project");
-			return true;
-		}
-		return false;
-	}
-	/**
-	* Get an agent by ID
-	*/
-	getAgent(id) {
-		return this.agentMap.get(id);
-	}
-	/**
-	* Add an agent to the project
-	*/
-	addAgent(agent$1) {
-		this.agents.push(agent$1);
-		this.agentMap.set(agent$1.getId(), agent$1);
-		agent$1.setConfig(this.tenantId, this.projectId, this.baseURL);
-		logger$5.info({
-			projectId: this.projectId,
-			agentId: agent$1.getId()
-		}, "Agent added to project");
-	}
-	/**
-	* Remove an agent from the project
-	*/
-	removeAgent(id) {
-		if (this.agentMap.get(id)) {
-			this.agentMap.delete(id);
-			this.agents = this.agents.filter((agent$1) => agent$1.getId() !== id);
-			logger$5.info({
-				projectId: this.projectId,
-				agentId: id
-			}, "Agent removed from project");
-			return true;
-		}
-		return false;
-	}
-	/**
-	* Get project statistics
-	*/
-	getStats() {
-		return {
-			projectId: this.projectId,
-			tenantId: this.tenantId,
-			agentCount: this.agents.length,
-			initialized: this.initialized
-		};
-	}
-	/**
-	* Validate the project configuration
-	*/
-	validate() {
-		const errors = [];
-		if (!this.projectId) errors.push("Project must have an ID");
-		if (!this.projectName) errors.push("Project must have a name");
-		const agentIds = /* @__PURE__ */ new Set();
-		for (const agent$1 of this.agents) {
-			const id = agent$1.getId();
-			if (agentIds.has(id)) errors.push(`Duplicate agent ID: ${id}`);
-			agentIds.add(id);
-		}
-		for (const agent$1 of this.agents) {
-			const agentValidation = agent$1.validate();
-			if (!agentValidation.valid) errors.push(...agentValidation.errors.map((error) => `Agent '${agent$1.getId()}': ${error}`));
-		}
-		return {
-			valid: errors.length === 0,
-			errors
-		};
-	}
-	/**
-	* Convert the Project to FullProjectDefinition format
-	*/
-	async toFullProjectDefinition() {
-		const agentsObject = {};
-		const toolsObject = {};
-		const functionToolsObject = {};
-		const functionsObject = {};
-		const dataComponentsObject = {};
-		const artifactComponentsObject = {};
-		const credentialReferencesObject = {};
-		const externalAgentsObject = {};
-		const credentialUsageMap = {};
-		for (const agent$1 of this.agents) {
-			logger$5.info({ agentId: agent$1.getId() }, "Agent id");
-			const agentDefinition = await agent$1.toFullAgentDefinition();
-			agentsObject[agent$1.getId()] = agentDefinition;
-			const agentCredentials = agent$1.credentials;
-			if (agentCredentials && Array.isArray(agentCredentials)) for (const credential$1 of agentCredentials) {
-				if (credential$1?.__type === "credential-ref") continue;
-				if (credential$1?.id) {
-					if (!credentialReferencesObject[credential$1.id]) {
-						credentialReferencesObject[credential$1.id] = {
-							id: credential$1.id,
-							name: credential$1.name,
-							type: credential$1.type,
-							credentialStoreId: credential$1.credentialStoreId,
-							retrievalParams: credential$1.retrievalParams
-						};
-						credentialUsageMap[credential$1.id] = [];
-					}
-					credentialUsageMap[credential$1.id].push({
-						type: "agent",
-						id: agent$1.getId()
-					});
-				}
-			}
-			const agentContextConfig = agent$1.contextConfig;
-			if (agentContextConfig) {
-				const contextVariables = agentContextConfig.getContextVariables?.() || agentContextConfig.contextVariables;
-				if (contextVariables) {
-					for (const [key, variable] of Object.entries(contextVariables)) if (variable?.credential) {
-						const credential$1 = variable.credential;
-						let credId;
-						if (credential$1.__type === "credential-ref") {
-							credId = credential$1.id;
-							if (credId && this.credentialReferences) {
-								const resolvedCred = this.credentialReferences.find((c) => c.id === credId);
-								if (resolvedCred && !credentialReferencesObject[credId]) {
-									credentialReferencesObject[credId] = resolvedCred;
-									credentialUsageMap[credId] = [];
-								}
-							}
-						} else if (credential$1.id) {
-							credId = credential$1.id;
-							if (credId && !credentialReferencesObject[credId]) {
-								credentialReferencesObject[credId] = credential$1;
-								credentialUsageMap[credId] = [];
-							}
-						}
-						if (credId) {
-							if (!credentialUsageMap[credId]) credentialUsageMap[credId] = [];
-							credentialUsageMap[credId].push({
-								type: "contextVariable",
-								id: key,
-								agentId: agent$1.getId()
-							});
-						}
-					} else if (variable?.credentialReferenceId) {
-						const credId = variable.credentialReferenceId;
-						if (!credentialUsageMap[credId]) credentialUsageMap[credId] = [];
-						credentialUsageMap[credId].push({
-							type: "contextVariable",
-							id: key,
-							agentId: agent$1.getId()
-						});
-					}
-				}
-			}
-			for (const subAgent$1 of agent$1.getSubAgents()) {
-				const agentTools = subAgent$1.getTools();
-				for (const [, toolInstance] of Object.entries(agentTools)) {
-					const actualTool = toolInstance;
-					const toolId = actualTool.getId();
-					if (actualTool.constructor.name === "FunctionTool" && actualTool instanceof FunctionTool) {
-						if (!functionsObject[toolId]) functionsObject[toolId] = actualTool.serializeFunction();
-						if (!functionToolsObject[toolId]) {
-							const toolData = actualTool.serializeTool();
-							functionToolsObject[toolId] = {
-								id: toolData.id,
-								name: toolData.name,
-								description: toolData.description,
-								functionId: toolData.functionId
-							};
-						}
-					} else if (!toolsObject[toolId]) {
-						if ("config" in actualTool && "serverUrl" in actualTool.config) {
-							const mcpTool$1 = actualTool;
-							const toolConfig = {
-								type: "mcp",
-								mcp: {
-									server: { url: mcpTool$1.config.serverUrl },
-									transport: mcpTool$1.config.transport,
-									activeTools: mcpTool$1.config.activeTools
-								}
-							};
-							const toolData = {
-								id: toolId,
-								name: actualTool.getName(),
-								config: toolConfig
-							};
-							if (mcpTool$1.config?.imageUrl) toolData.imageUrl = mcpTool$1.config.imageUrl;
-							if (mcpTool$1.config?.headers) toolData.headers = mcpTool$1.config.headers;
-							if ("getCredentialReferenceId" in actualTool) {
-								const credentialId = actualTool.getCredentialReferenceId();
-								if (credentialId) toolData.credentialReferenceId = credentialId;
-							}
-							if ("credential" in mcpTool$1.config && mcpTool$1.config.credential) {
-								const credential$1 = mcpTool$1.config.credential;
-								if (credential$1?.id && credential$1.__type !== "credential-ref") {
-									if (!credentialReferencesObject[credential$1.id]) {
-										credentialReferencesObject[credential$1.id] = {
-											id: credential$1.id,
-											name: credential$1.name,
-											type: credential$1.type,
-											credentialStoreId: credential$1.credentialStoreId,
-											retrievalParams: credential$1.retrievalParams
-										};
-										credentialUsageMap[credential$1.id] = [];
-									}
-									credentialUsageMap[credential$1.id].push({
-										type: "tool",
-										id: toolId
-									});
-								}
-							}
-							toolsObject[toolId] = toolData;
-						}
-					}
-				}
-				const subAgentDataComponents = subAgent$1.getDataComponents?.();
-				if (subAgentDataComponents) for (const dataComponent$1 of subAgentDataComponents) {
-					let dataComponentId;
-					let dataComponentName;
-					let dataComponentDescription;
-					let dataComponentProps;
-					let dataComponentRender;
-					if (dataComponent$1.getId) {
-						dataComponentId = dataComponent$1.getId();
-						dataComponentName = dataComponent$1.getName();
-						dataComponentDescription = dataComponent$1.getDescription() || "";
-						dataComponentProps = dataComponent$1.getProps() || {};
-						dataComponentRender = dataComponent$1.getRender?.() || null;
-					} else {
-						dataComponentId = dataComponent$1.id || (dataComponent$1.name ? dataComponent$1.name.toLowerCase().replace(/\s+/g, "-") : "");
-						dataComponentName = dataComponent$1.name || "";
-						dataComponentDescription = dataComponent$1.description || "";
-						dataComponentProps = dataComponent$1.props || {};
-						dataComponentRender = dataComponent$1.render || null;
-					}
-					if (!dataComponentsObject[dataComponentId] && dataComponentName) dataComponentsObject[dataComponentId] = {
-						id: dataComponentId,
-						name: dataComponentName,
-						description: dataComponentDescription,
-						props: dataComponentProps,
-						render: dataComponentRender
-					};
-				}
-				const subAgentArtifactComponents = subAgent$1.getArtifactComponents();
-				if (subAgentArtifactComponents) for (const artifactComponent$1 of subAgentArtifactComponents) {
-					let artifactComponentId;
-					let artifactComponentName;
-					let artifactComponentDescription;
-					let artifactComponentProps;
-					if ("getId" in artifactComponent$1 && typeof artifactComponent$1.getId === "function") {
-						const component = artifactComponent$1;
-						artifactComponentId = component.getId();
-						artifactComponentName = component.getName();
-						artifactComponentDescription = component.getDescription() || "";
-						artifactComponentProps = component.getProps() || {};
-					} else {
-						artifactComponentId = artifactComponent$1.id || (artifactComponent$1.name ? artifactComponent$1.name.toLowerCase().replace(/\s+/g, "-") : "");
-						artifactComponentName = artifactComponent$1.name || "";
-						artifactComponentDescription = artifactComponent$1.description || "";
-						artifactComponentProps = artifactComponent$1.props || {};
-					}
-					if (!artifactComponentsObject[artifactComponentId] && artifactComponentName) artifactComponentsObject[artifactComponentId] = {
-						id: artifactComponentId,
-						name: artifactComponentName,
-						description: artifactComponentDescription,
-						props: artifactComponentProps
-					};
-				}
-				const subAgentExternalAgents = subAgent$1.getExternalAgentDelegates();
-				if (subAgentExternalAgents) for (const externalAgentDelegate of subAgentExternalAgents) {
-					const externalAgent$1 = externalAgentDelegate.externalAgent;
-					const credential$1 = externalAgent$1.getCredentialReference();
-					if (credential$1) {
-						if (!credentialReferencesObject[credential$1.id]) {
-							credentialReferencesObject[credential$1.id] = {
-								id: credential$1.id,
-								name: credential$1.name,
-								type: credential$1.type,
-								credentialStoreId: credential$1.credentialStoreId,
-								retrievalParams: credential$1.retrievalParams
-							};
-							credentialUsageMap[credential$1.id] = [];
-						}
-						logger$5.info({ credentialId: credential$1.id }, "Credential id in external agent");
-						credentialUsageMap[credential$1.id].push({
-							type: "externalAgent",
-							id: externalAgent$1.getId()
-						});
-					}
-					logger$5.info({ externalAgentId: externalAgent$1.getId() }, "External agent id");
-					externalAgentsObject[externalAgent$1.getId()] = {
-						id: externalAgent$1.getId(),
-						name: externalAgent$1.getName(),
-						description: externalAgent$1.getDescription(),
-						baseUrl: externalAgent$1.getBaseUrl(),
-						credentialReferenceId: externalAgent$1.getCredentialReferenceId()
-					};
-				}
-			}
-		}
-		logger$5.info({ externalAgentsObject }, "External agents object");
-		for (const tool of this.projectTools) {
-			const toolId = tool.getId();
-			if (!toolsObject[toolId]) {
-				const toolConfig = {
-					type: "mcp",
-					mcp: {
-						server: { url: tool.config.serverUrl },
-						transport: tool.config.transport,
-						activeTools: tool.config.activeTools
-					}
-				};
-				const toolData = {
-					id: toolId,
-					name: tool.getName(),
-					config: toolConfig
-				};
-				if (tool.config?.imageUrl) toolData.imageUrl = tool.config.imageUrl;
-				if (tool.config?.headers) toolData.headers = tool.config.headers;
-				const credentialId = tool.getCredentialReferenceId();
-				if (credentialId) toolData.credentialReferenceId = credentialId;
-				toolsObject[toolId] = toolData;
-			}
-		}
-		for (const dataComponent$1 of this.projectDataComponents) {
-			const dataComponentId = dataComponent$1.getId();
-			const dataComponentName = dataComponent$1.getName();
-			const dataComponentDescription = dataComponent$1.getDescription() || "";
-			const dataComponentProps = dataComponent$1.getProps() || {};
-			if (!dataComponentsObject[dataComponentId] && dataComponentName) dataComponentsObject[dataComponentId] = {
-				id: dataComponentId,
-				name: dataComponentName,
-				description: dataComponentDescription,
-				props: dataComponentProps
-			};
-		}
-		for (const artifactComponent$1 of this.projectArtifactComponents) {
-			const artifactComponentId = artifactComponent$1.getId();
-			const artifactComponentName = artifactComponent$1.getName();
-			const artifactComponentDescription = artifactComponent$1.getDescription() || "";
-			const artifactComponentProps = artifactComponent$1.getProps() || {};
-			if (!artifactComponentsObject[artifactComponentId] && artifactComponentName) artifactComponentsObject[artifactComponentId] = {
-				id: artifactComponentId,
-				name: artifactComponentName,
-				description: artifactComponentDescription,
-				props: artifactComponentProps
-			};
-		}
-		if (this.credentialReferences && this.credentialReferences.length > 0) {
-			for (const credential$1 of this.credentialReferences) if (credential$1.id) {
-				if (!credentialReferencesObject[credential$1.id]) {
-					credentialReferencesObject[credential$1.id] = credential$1;
-					credentialUsageMap[credential$1.id] = [];
-				}
-			}
-		}
-		for (const [credId, usages] of Object.entries(credentialUsageMap)) if (credentialReferencesObject[credId]) credentialReferencesObject[credId].usedBy = usages;
-		return {
-			id: this.projectId,
-			name: this.projectName,
-			description: this.projectDescription || "",
-			models: this.models,
-			stopWhen: this.stopWhen,
-			agents: agentsObject,
-			tools: toolsObject,
-			functionTools: Object.keys(functionToolsObject).length > 0 ? functionToolsObject : void 0,
-			functions: Object.keys(functionsObject).length > 0 ? functionsObject : void 0,
-			dataComponents: Object.keys(dataComponentsObject).length > 0 ? dataComponentsObject : void 0,
-			artifactComponents: Object.keys(artifactComponentsObject).length > 0 ? artifactComponentsObject : void 0,
-			externalAgents: Object.keys(externalAgentsObject).length > 0 ? externalAgentsObject : void 0,
-			credentialReferences: Object.keys(credentialReferencesObject).length > 0 ? credentialReferencesObject : void 0,
-			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-		};
-	}
-};
-
-//#endregion
-//#region src/status-component.ts
-const logger$4 = (0, __inkeep_agents_core.getLogger)("statusComponent");
-var StatusComponent = class {
-	config;
-	constructor(config) {
-		let processedDetailsSchema;
-		if (config.detailsSchema && (0, __inkeep_agents_core_utils_schema_conversion.isZodSchema)(config.detailsSchema)) {
-			const jsonSchema = (0, __inkeep_agents_core_utils_schema_conversion.convertZodToJsonSchema)(config.detailsSchema);
-			processedDetailsSchema = {
-				type: "object",
-				properties: jsonSchema.properties || {},
-				required: jsonSchema.required || void 0
-			};
-		} else processedDetailsSchema = config.detailsSchema;
-		this.config = {
-			...config,
-			detailsSchema: processedDetailsSchema
-		};
-		logger$4.info({ statusComponentType: config.type }, "StatusComponent constructor initialized");
-	}
-	getType() {
-		return this.config.type;
-	}
-	getDescription() {
-		return this.config.description;
-	}
-	getDetailsSchema() {
-		return this.config.detailsSchema;
-	}
-};
-
-//#endregion
-//#region src/tool.ts
-const logger$3 = (0, __inkeep_agents_core.getLogger)("tool");
-var Tool = class {
-	config;
-	baseURL;
-	tenantId;
-	initialized = false;
-	projectId;
-	constructor(config) {
-		this.config = config;
-		this.baseURL = process.env.INKEEP_API_URL || "http://localhost:3002";
-		this.tenantId = "default";
-		this.projectId = "default";
-		logger$3.info({
-			Id: this.getId(),
-			Name: config.name
-		}, "Tool 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;
-	}
-	getDescription() {
-		return this.config.description || "";
-	}
-	getServerUrl() {
-		return this.config.serverUrl;
-	}
-	getActiveTools() {
-		return this.config.activeTools;
-	}
-	getCredentialReferenceId() {
-		return this.config.credential?.id;
-	}
-	async init(options) {
-		if (this.initialized) return;
-		try {
-			if (!options?.skipDatabaseRegistration) await this.upsertTool();
-			logger$3.info({ toolId: this.getId() }, "Tool initialized successfully");
-			this.initialized = true;
-		} catch (error) {
-			logger$3.error({
-				toolId: this.getId(),
-				error: error instanceof Error ? error.message : "Unknown error"
-			}, "Failed to initialize tool");
-			throw error;
-		}
-	}
-	async upsertTool() {
-		const toolDataForUpdate = {
-			id: this.getId(),
-			name: this.config.name,
-			credentialReferenceId: this.config.credential?.id ?? null,
-			headers: this.config.headers ?? null,
-			imageUrl: this.config.imageUrl,
-			config: {
-				type: "mcp",
-				mcp: {
-					server: { url: this.config.serverUrl },
-					transport: this.config.transport,
-					activeTools: this.config.activeTools
-				}
-			}
-		};
-		const toolDataForCreate = { ...toolDataForUpdate };
-		logger$3.info({ toolDataForCreate }, "toolDataForCreate");
-		const updateResponse = await fetch(`${this.baseURL}/tenants/${this.tenantId}/projects/${this.projectId}/tools/${this.getId()}`, {
-			method: "PUT",
-			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify(toolDataForUpdate)
-		});
-		logger$3.info({ updateResponse }, "tool updateResponse");
-		if (updateResponse.ok) {
-			logger$3.info({ toolId: this.getId() }, "Tool updated successfully");
-			return;
-		}
-		if (updateResponse.status === 404) {
-			logger$3.info({ toolId: this.getId() }, "Tool not found, creating new tool");
-			const createResponse = await fetch(`${this.baseURL}/tenants/${this.tenantId}/projects/${this.projectId}/tools`, {
-				method: "POST",
-				headers: { "Content-Type": "application/json" },
-				body: JSON.stringify(toolDataForCreate)
-			});
-			if (!createResponse.ok) throw new Error(`Failed to create tool: ${createResponse.status}`);
-			logger$3.info({ toolId: this.getId() }, "Tool created successfully");
-			return;
-		}
-		throw new Error(`Failed to update tool: ${updateResponse.status}`);
-	}
-	/**
-	* Creates a new AgentMcpConfig with the given configuration.
-	*
-	* @param config - The configuration for the AgentMcpConfig
-	* @returns A new AgentMcpConfig
-	*
-	* example:
-	* ```typescript
-	* const tool = new Tool({
-	*   id: 'tool-id',
-	*   name: 'Tool Name',
-	*   serverUrl: 'https://example.com/mcp',
-	* });
-	* const agentMcpConfig = tool.with({ selectedTools: ['tool-1', 'tool-2'], headers: { 'Authorization': 'Bearer token' } });
-	* ```
-	*/
-	with(config) {
-		const { selectedTools, toolPolicies } = (0, __inkeep_agents_core.normalizeToolSelections)(config.selectedTools ?? void 0);
-		const isUnspecified = config.selectedTools === void 0 || config.selectedTools === null;
-		const resolvedSelectedTools = isUnspecified ? void 0 : selectedTools;
-		const resolvedToolPolicies = isUnspecified || Object.keys(toolPolicies).length === 0 ? void 0 : toolPolicies;
-		return {
-			server: this,
-			selectedTools: resolvedSelectedTools,
-			headers: config.headers,
-			toolPolicies: resolvedToolPolicies
-		};
-	}
-};
-
-//#endregion
-//#region src/utils/tool-normalization.ts
-/**
-* Type guard to check if a value is an AgentMcpConfig
-*/
-function isAgentMcpConfig(value) {
-	return value !== null && typeof value === "object" && "server" in value && value.server && typeof value.server === "object";
-}
-/**
-* Type guard to check if a value is a Tool instance
-*/
-function isTool(value) {
-	return value !== null && typeof value === "object" && "config" in value && (typeof value.getId === "function" || "id" in value);
-}
-/**
-* Safely extracts tool information from AgentCanUseType with proper typing
-*/
-function normalizeAgentCanUseType(value, fallbackName) {
-	if (isAgentMcpConfig(value)) return {
-		tool: value.server,
-		toolId: value.server.getId(),
-		selectedTools: value.selectedTools,
-		headers: value.headers,
-		toolPolicies: value.toolPolicies,
-		isWrapped: true
-	};
-	if (isTool(value)) return {
-		tool: value,
-		toolId: value.getId?.() || value.id || fallbackName || "unknown",
-		isWrapped: false
-	};
-	throw new Error(`Invalid AgentCanUseType: expected Tool or AgentMcpConfig, got ${typeof value}`);
-}
-
-//#endregion
-//#region src/subAgent.ts
-const logger$2 = (0, __inkeep_agents_core.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$2.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 && (0, __inkeep_agents_core_utils_schema_conversion.isZodSchema)(comp.props)) return {
-				id: comp.id,
-				name: comp.name,
-				description: comp.description,
-				props: (0, __inkeep_agents_core_utils_schema_conversion.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 && (0, __inkeep_agents_core_utils_schema_conversion.isZodSchema)(comp.props)) return {
-				id: comp.id,
-				name: comp.name,
-				description: comp.description,
-				props: (0, __inkeep_agents_core_utils_schema_conversion.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$2.info({ subAgentId: this.getId() }, "Agent initialized successfully");
-			this.initialized = true;
-		} catch (error) {
-			logger$2.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$2.info({ subAgentId: this.getId() }, "Agent updated successfully");
-			return;
-		}
-		if (updateResponse.status === 404) {
-			logger$2.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$2.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$2.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$2.info({ dataComponents: this.config.dataComponents }, "dataComponents and config");
-		const components = resolveGetter(this.config.dataComponents);
-		if (components) for (const dataComponent$1 of components) {
-			const plainComponent = dataComponent$1 && typeof dataComponent$1.getId === "function" ? {
-				id: dataComponent$1.getId(),
-				name: dataComponent$1.getName(),
-				description: dataComponent$1.getDescription(),
-				props: dataComponent$1.getProps()
-			} : dataComponent$1;
-			await this.createDataComponent(plainComponent);
-		}
-	}
-	async saveArtifactComponents() {
-		logger$2.info({ artifactComponents: this.config.artifactComponents }, "artifactComponents and config");
-		const components = resolveGetter(this.config.artifactComponents);
-		if (components) for (const artifactComponent$1 of components) {
-			const plainComponent = artifactComponent$1 && typeof artifactComponent$1.getId === "function" ? {
-				id: artifactComponent$1.getId(),
-				name: artifactComponent$1.getName(),
-				description: artifactComponent$1.getDescription(),
-				props: artifactComponent$1.getProps?.() || artifactComponent$1.props
-			} : artifactComponent$1;
-			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$2.info({
-				subAgentId: this.getId(),
-				dbComponentCount: dbDataComponents.length,
-				configComponentCount: configComponents.length,
-				totalComponentCount: uniqueComponents.length
-			}, "Loaded and merged data components");
-		} catch (error) {
-			logger$2.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$2.info({
-				subAgentId: this.getId(),
-				dbComponentCount: dbArtifactComponents.length,
-				configComponentCount: configComponents.length,
-				totalComponentCount: uniqueComponents.length
-			}, "Loaded and merged artifact components");
-		} catch (error) {
-			logger$2.error({
-				subAgentId: this.getId(),
-				error: error instanceof Error ? error.message : "Unknown error"
-			}, "Failed to load artifact components from database");
-		}
-	}
-	async createFunctionTool(toolId, functionTool$1) {
-		try {
-			const functionData = functionTool$1.serializeFunction();
-			const toolData = functionTool$1.serializeTool();
-			const functionUrl = `${this.baseURL}/tenants/${this.tenantId}/crud/projects/${this.projectId}/functions`;
-			logger$2.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$2.info({
-				agentId: this.getId(),
-				toolId,
-				functionStatus: functionResponse.status,
-				functionStatusText: functionResponse.statusText
-			}, "Function creation response received");
-			if (!functionResponse.ok) {
-				const errorText = await functionResponse.text();
-				logger$2.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$2.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$2.info({
-				agentId: this.getId(),
-				toolId,
-				toolStatus: toolResponse.status,
-				toolStatusText: toolResponse.statusText
-			}, "Tool creation response received");
-			if (!toolResponse.ok) {
-				const errorText = await toolResponse.text();
-				logger$2.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$2.info({
-				agentId: this.getId(),
-				functionId: functionData.id,
-				toolId: toolData.id
-			}, "Function and tool created successfully");
-		} catch (error) {
-			logger$2.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$2.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$2.info({
-				subAgentId: this.getId(),
-				toolId: tool.getId()
-			}, "Tool created and linked to agent");
-		} catch (error) {
-			logger$2.error({
-				subAgentId: this.getId(),
-				toolId,
-				error: error instanceof Error ? error.message : "Unknown error"
-			}, "Failed to create tool");
-			throw error;
-		}
-	}
-	async createDataComponent(dataComponent$1) {
-		try {
-			const dc = new DataComponent({
-				id: dataComponent$1.id,
-				name: dataComponent$1.name,
-				description: dataComponent$1.description,
-				props: dataComponent$1.props,
-				render: dataComponent$1.render
-			});
-			dc.setContext(this.tenantId, this.projectId);
-			await dc.init();
-			await this.createAgentDataComponentRelation(dc.getId());
-			logger$2.info({
-				subAgentId: this.getId(),
-				dataComponentId: dc.getId()
-			}, "DataComponent created and linked to agent");
-		} catch (error) {
-			logger$2.error({
-				subAgentId: this.getId(),
-				dataComponentName: dataComponent$1.name,
-				error: error instanceof Error ? error.message : "Unknown error"
-			}, "Failed to create data component");
-			throw error;
-		}
-	}
-	async createArtifactComponent(artifactComponent$1) {
-		try {
-			const ac = new ArtifactComponent({
-				id: artifactComponent$1.id,
-				name: artifactComponent$1.name,
-				description: artifactComponent$1.description,
-				props: artifactComponent$1.props
-			});
-			ac.setContext(this.tenantId, this.projectId);
-			await ac.init();
-			await this.createAgentArtifactComponentRelation(ac.getId());
-			logger$2.info({
-				subAgentId: this.getId(),
-				artifactComponentId: ac.getId()
-			}, "ArtifactComponent created and linked to agent");
-		} catch (error) {
-			logger$2.error({
-				subAgentId: this.getId(),
-				artifactComponentName: artifactComponent$1.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$2.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$2.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}`);
-		}
-	}
-};
-
-//#endregion
-//#region src/builderFunctions.ts
-/**
-* Helper function to create agent - OpenAI style
-*/
-function agent(config) {
-	return new Agent(config);
-}
-/**
-* Helper function to create projects - OpenAI style
-*
-* Projects are the top-level organizational unit that contains Agents, Sub Agents, and shared configurations.
-* They provide model inheritance and execution limits that cascade down to Agents and Sub Agents.
-*
-* @param config - Project configuration
-* @returns A new Project instance
-*
-* @example
-* ```typescript
-* const customerSupport = project({
-*   id: 'customer-support-project',
-*   name: 'Customer Support System',
-*   description: 'Multi-agent customer support system',
-*   models: {
-*     base: { model: 'gpt-4.1-mini' },
-*     structuredOutput: { model: 'gpt-4.1' }
-*   },
-*   stopWhen: {
-*     transferCountIs: 10,
-*     stepCountIs: 50
-*   },
-*   agent: () => [
-*     agent({
-*       id: 'support-agent',
-*       name: 'Support Agent',
-*       // ... agent config
-*     })
-*   ]
-* });
-* ```
-*/
-function project(config) {
-	return new Project(config);
-}
-/**
-* Creates a new agent with stable ID enforcement.
-*
-* Agents require explicit stable IDs to ensure consistency across deployments.
-* This is different from tools which auto-generate IDs from their names.
-*
-* @param config - Agent configuration including required stable ID
-* @returns A new SubAgent instance
-* @throws {Error} If config.id is not provided
-*
-* @example
-* ```typescript
-* const myAgent = agent({
-*   id: 'customer-support-agent',
-*   name: 'Customer Support',
-*   prompt: 'Help customers with their questions'
-* });
-* ```
-*/
-function subAgent(config) {
-	if (!config.id) throw new Error("Sub-Agent ID is required. Sub-Agents must have stable IDs for consistency across deployments.");
-	return new SubAgent(config);
-}
-/**
-* Creates a credential reference for authentication.
-*
-* Credentials are used to authenticate with external services.
-* They should be stored securely and referenced by ID.
-*
-* @param config - Credential configuration
-* @returns A validated credential reference
-*
-* @example
-* ```typescript
-* const apiCredential = credential({
-*   id: 'github-token',
-*   name: 'GitHub Token',
-*   type: 'bearer',
-*   value: process.env.GITHUB_TOKEN
-* });
-* ```
-*/
-function credential(config) {
-	try {
-		return __inkeep_agents_core.CredentialReferenceApiInsertSchema.parse(config);
-	} catch (error) {
-		if (error instanceof Error) {
-			const credId = config.id || "unknown";
-			throw new Error(`Invalid credential '${credId}': ${error.message}`);
-		}
-		throw error;
-	}
-}
-/**
-* Creates an MCP (Model Context Protocol) server for tool functionality.
-*
-* MCP servers provide tool functionality through a standardized protocol.
-* They can be remote services accessed via HTTP/WebSocket.
-*
-* @param config - MCP server configuration
-* @returns A Tool instance configured as an MCP server
-* @throws {Error} If serverUrl is not provided
-*
-* @example
-* ```typescript
-* // Remote MCP server
-* const apiServer = mcpServer({
-*   name: 'external_api',
-*   description: 'External API service',
-*   serverUrl: 'https://api.example.com/mcp'
-* });
-*
-* // With authentication
-* const secureServer = mcpServer({
-*   name: 'secure_api',
-*   description: 'Secure API service',
-*   serverUrl: 'https://secure.example.com/mcp',
-*   credential: credential({
-*     id: 'api-key',
-*     name: 'API Key',
-*     type: 'bearer',
-*     value: process.env.API_KEY
-*   })
-* });
-* ```
-*/
-function mcpServer(config) {
-	if (!config.serverUrl) throw new Error("MCP server requires a serverUrl");
-	return new Tool({
-		id: config.id || generateIdFromName(config.name),
-		name: config.name,
-		description: config.description,
-		serverUrl: config.serverUrl,
-		credential: config.credential,
-		activeTools: config.activeTools,
-		headers: config.headers,
-		imageUrl: config.imageUrl,
-		transport: config.transport ? { type: config.transport } : void 0
-	});
-}
-/**
-* Creates an MCP tool from a raw configuration object.
-*
-* This is a low-level builder for advanced use cases where you need
-* full control over the MCPToolConfig. For most cases, use `mcpServer()`.
-*
-* @param config - Complete MCP tool configuration
-* @returns A Tool instance
-*
-* @example
-* ```typescript
-* const customTool = mcpTool({
-*   id: 'custom-tool',
-*   name: 'Custom Tool',
-*   serverUrl: 'https://example.com/mcp',
-*   transport: { type: 'stdio' }
-* });
-* ```
-*/
-function mcpTool(config) {
-	const configWithId = {
-		...config,
-		id: config.id || generateIdFromName(config.name)
-	};
-	return new Tool(__inkeep_agents_core.MCPToolConfigSchema.parse(configWithId));
-}
-/**
-* Creates an artifact component with automatic ID generation.
-*
-* Artifact components represent structured UI components that can
-* be rendered with different levels of detail (summary vs full).
-*
-* @param config - Artifact component configuration
-* @returns An ArtifactComponent instance
-*
-* @example
-* ```typescript
-* const productCard = artifactComponent({
-*   name: 'Product Card',
-*   description: 'Display product information',
-*   props: {
-*     type: 'object',
-*     properties: {
-*       title: { type: 'string', inPreview: true },
-*       price: { type: 'string', inPreview: true },
-*       description: { type: 'string' },
-*       image: { type: 'string' }
-*     }
-*   }
-* });
-* ```
-*/
-function artifactComponent(config) {
-	return new ArtifactComponent({
-		...config,
-		id: config.id || generateIdFromName(config.name)
-	});
-}
-/**
-* Creates a data component with automatic ID generation.
-*
-* Data components represent structured data that can be
-* passed between agents or used in processing.
-*
-* @param config - Data component configuration
-* @returns A DataComponent instance
-*
-* @example
-* ```typescript
-* const userProfile = dataComponent({
-*   name: 'User Profile',
-*   description: 'User profile data',
-*   props: {
-*     userId: '123',
-*     name: 'John Doe',
-*     email: 'john@example.com'
-*   }
-* });
-* ```
-*/
-function dataComponent(config) {
-	return new DataComponent({
-		...config,
-		id: config.id || generateIdFromName(config.name)
-	});
-}
-/**
-* Creates a status component for structured status updates.
-*
-* Status components define the structure of status updates
-* that agents can generate during long-running operations.
-*
-* @param config - Status component configuration
-* @returns A StatusComponent instance
-*
-* @example
-* ```typescript
-* import { z } from 'zod';
-*
-* const toolCallStatus = statusComponent({
-*   type: 'tool_call_summary',
-*   description: 'Summary of a tool execution',
-*   detailsSchema: z.object({
-*     tool_name: z.string(),
-*     summary: z.string(),
-*     status: z.enum(['success', 'error', 'in_progress'])
-*   })
-* });
-* ```
-*/
-function statusComponent(config) {
-	return new StatusComponent(config);
-}
-/**
-* (deprecated in favor of mcpTool.with()) Creates an agent MCP configuration.
-*
-* Agent MCP configurations are used to configure the MCP server for an agent.
-*
-* @param config - Agent MCP configuration
-* @returns An AgentMcpConfig instance
-*/
-function agentMcp(config) {
-	return {
-		server: config.server,
-		selectedTools: config.selectedTools,
-		headers: config.headers
-	};
-}
-/**
-* Creates a function tool that executes user-defined code in a sandboxed environment.
-*
-* Function tools allow users to define custom logic that runs securely in isolated
-* environments. Dependencies are installed automatically in the sandbox.
-*
-* @param config - Function tool configuration
-* @returns A FunctionTool instance
-*
-* @example
-* ```typescript
-* const calculatorTool = functionTool({
-*   name: 'calculator',
-*   description: 'Performs basic math operations',
-*   inputSchema: {
-*     type: 'object',
-*     properties: {
-*       operation: { type: 'string', enum: ['add', 'subtract', 'multiply', 'divide'] },
-*       a: { type: 'number' },
-*       b: { type: 'number' }
-*     },
-*     required: ['operation', 'a', 'b']
-*   },
-*   dependencies: {
-*     'lodash': '^4.17.21'
-*   },
-*   execute: async (params) => {
-*     const { operation, a, b } = params;
-*     switch (operation) {
-*       case 'add': return { result: a + b };
-*       case 'subtract': return { result: a - b };
-*       case 'multiply': return { result: a * b };
-*       case 'divide': return { result: a / b };
-*       default: throw new Error(`Unknown operation: ${operation}`);
-*     }
-*   }
-* });
-* ```
-*/
-function functionTool(config) {
-	return new FunctionTool(config);
-}
-
-//#endregion
-//#region src/utils/validateFunction.ts
-/**
-* Validates that a value is a function
-* @param value - The value to check
-* @param name - The name of the parameter (for error messages)
-* @throws {Error} If the value is not a function
-*/
-function validateFunction(value, name) {
-	if (typeof value !== "function") throw new Error(`${name} must be a function`);
-}
-
-//#endregion
-//#region src/builders.ts
-/**
-* Schema for transfer configuration (excluding function properties)
-*/
-const TransferConfigSchema = zod.z.object({
-	agent: zod.z.instanceof(SubAgent),
-	description: zod.z.string().optional()
-});
-/**
-* Creates a transfer configuration for agent transfers.
-*
-* Transfers allow one agent to hand off control to another agent
-* based on optional conditions.
-*
-* @param targetAgent - The agent to transfer to
-* @param description - Optional description of when/why to transfer
-* @param condition - Optional function to determine if transfer should occur
-* @returns A validated transfer configuration
-*
-* @example
-* ```typescript
-* // Simple transfer
-* const transfer = transfer(supportAgent, 'Transfer to support');
-*
-* // Conditional transfer
-* const conditionalHandoff = transfer(
-*   specialistAgent,
-*   'Transfer to specialist for complex issues',
-*   (context) => context.complexity > 0.8
-* );
-* ```
-*/
-function transfer(targetAgent, description, condition) {
-	if (condition !== void 0) validateFunction(condition, "condition");
-	const config = {
-		agent: targetAgent,
-		description: description || `Hand off to ${targetAgent.getName()}`,
-		condition
-	};
-	TransferConfigSchema.parse({
-		agent: config.agent,
-		description: config.description
-	});
-	return config;
-}
-
-//#endregion
-//#region src/credential-provider.ts
-/**
-* Default configuration using memory store
-*/
-const DEFAULT_CONFIG = {
-	type: "memory",
-	id: "memory-default"
-};
-/**
-* Simple in-memory credential store implementation
-* Automatically loads from environment variables as fallback
-*/
-var InMemoryStore = class {
-	id;
-	type = "memory";
-	credentials = /* @__PURE__ */ new Map();
-	constructor(id = "memory-default") {
-		this.id = id;
-	}
-	async get(key) {
-		const credential$1 = this.credentials.get(key);
-		if (!credential$1) {
-			const envValue = process.env[key];
-			if (envValue) {
-				this.credentials.set(key, envValue);
-				return envValue;
-			}
-			return null;
-		}
-		return credential$1;
-	}
-	async set(key, value, _metadata) {
-		this.credentials.set(key, value);
-	}
-	async has(key) {
-		return this.credentials.has(key) || !!process.env[key];
-	}
-	async delete(key) {
-		return this.credentials.delete(key);
-	}
-	async checkAvailability() {
-		return { available: true };
-	}
-};
-/**
-* InkeepCredentialProvider - Unified credential management for Inkeep SDK
-*
-* Provides a clean abstraction over various credential storage backends.
-* Cloud customers can use simple memory-based storage, while advanced
-* users can integrate with OAuth providers like Nango.
-*
-* @example
-* ```typescript
-* // Default memory-based storage
-* const provider = new InkeepCredentialProvider()
-*
-* // Store and retrieve credentials
-* await provider.set('my-api-key', 'secret-value')
-* const key = await provider.get('my-api-key')
-*
-* // Use environment variables automatically
-* process.env.MY_TOKEN = 'env-token'
-* const token = await provider.get('MY_TOKEN') // Returns 'env-token'
-* ```
-*/
-var InkeepCredentialProvider = class {
-	store;
-	constructor(config = DEFAULT_CONFIG) {
-		this.store = this.createStore(config);
-	}
-	/**
-	* Create the appropriate store based on configuration
-	*/
-	createStore(config) {
-		switch (config.type) {
-			case "memory": return new InMemoryStore(config.id);
-			case "keychain": return this.createKeychainStore(config);
-			case "nango": return this.createNangoStore(config);
-			case "custom": return config.store;
-			default: throw new Error(`Unknown credential provider type: ${config.type}`);
-		}
-	}
-	/**
-	* Create keychain store with dynamic import
-	*/
-	createKeychainStore(config) {
-		const storeId = config.id || "keychain-default";
-		return {
-			id: storeId,
-			type: "keychain",
-			get: async (key) => {
-				const { createKeyChainStore } = await import("@inkeep/agents-core/credential-stores");
-				return createKeyChainStore(storeId).get(key);
-			},
-			set: async (key, value, metadata) => {
-				const { createKeyChainStore } = await import("@inkeep/agents-core/credential-stores");
-				return createKeyChainStore(storeId).set(key, value, metadata);
-			},
-			has: async (key) => {
-				const { createKeyChainStore } = await import("@inkeep/agents-core/credential-stores");
-				return createKeyChainStore(storeId).has(key);
-			},
-			delete: async (key) => {
-				const { createKeyChainStore } = await import("@inkeep/agents-core/credential-stores");
-				return createKeyChainStore(storeId).delete(key);
-			},
-			checkAvailability: async () => {
-				try {
-					const { createKeyChainStore } = await import("@inkeep/agents-core/credential-stores");
-					return createKeyChainStore(storeId).checkAvailability();
-				} catch {
-					return {
-						available: false,
-						reason: "Keychain store requires keytar package to be installed"
-					};
-				}
-			}
-		};
-	}
-	/**
-	* Create Nango store with dynamic import
-	*/
-	createNangoStore(config) {
-		const storeId = config.id || "nango-default";
-		const secretKey = config.secretKey;
-		const apiUrl = config.apiUrl;
-		return {
-			id: storeId,
-			type: "nango",
-			get: async (key) => {
-				const { createNangoCredentialStore } = await import("@inkeep/agents-core/credential-stores");
-				return createNangoCredentialStore(storeId, {
-					secretKey,
-					apiUrl
-				}).get(key);
-			},
-			set: async (key, value, metadata) => {
-				const { createNangoCredentialStore } = await import("@inkeep/agents-core/credential-stores");
-				return createNangoCredentialStore(storeId, {
-					secretKey,
-					apiUrl
-				}).set(key, value, metadata);
-			},
-			has: async (key) => {
-				const { createNangoCredentialStore } = await import("@inkeep/agents-core/credential-stores");
-				return createNangoCredentialStore(storeId, {
-					secretKey,
-					apiUrl
-				}).has(key);
-			},
-			delete: async (key) => {
-				const { createNangoCredentialStore } = await import("@inkeep/agents-core/credential-stores");
-				return createNangoCredentialStore(storeId, {
-					secretKey,
-					apiUrl
-				}).delete(key);
-			},
-			checkAvailability: async () => {
-				try {
-					const { createNangoCredentialStore } = await import("@inkeep/agents-core/credential-stores");
-					return createNangoCredentialStore(storeId, {
-						secretKey,
-						apiUrl
-					}).checkAvailability();
-				} catch (error) {
-					return {
-						available: false,
-						reason: error instanceof Error ? error.message : "Nango store requires @nangohq/node package and NANGO_SECRET_KEY"
-					};
-				}
-			}
-		};
-	}
-	get id() {
-		return this.store.id;
-	}
-	get type() {
-		return this.store.type;
-	}
-	/**
-	* Get a credential by key
-	* @param key - The credential key
-	* @returns The credential value or null if not found
-	*/
-	async get(key) {
-		return this.store.get(key);
-	}
-	/**
-	* Set a credential
-	* @param key - The credential key
-	* @param value - The credential value
-	* @param metadata - Optional metadata
-	*/
-	async set(key, value, metadata) {
-		return this.store.set(key, value, metadata);
-	}
-	/**
-	* Check if a credential exists
-	* @param key - The credential key
-	* @returns True if the credential exists
-	*/
-	async has(key) {
-		return this.store.has(key);
-	}
-	/**
-	* Delete a credential
-	* @param key - The credential key
-	* @returns True if the credential was deleted
-	*/
-	async delete(key) {
-		return this.store.delete(key);
-	}
-	/**
-	* Check if the credential store is available and functional
-	* @returns Availability status
-	*/
-	async checkAvailability() {
-		return this.store.checkAvailability();
-	}
-	/**
-	* Get the underlying store (for advanced use cases)
-	*/
-	getStore() {
-		return this.store;
-	}
-};
-/**
-* Factory function to create an InkeepCredentialProvider
-* @param config - Configuration options
-* @returns A new InkeepCredentialProvider instance
-*/
-function createCredentialProvider(config = DEFAULT_CONFIG) {
-	return new InkeepCredentialProvider(config);
-}
-
-//#endregion
-//#region src/credential-ref.ts
-/**
-* Create a reference to a credential by its ID.
-* The credential must be defined in the environment files.
-*
-* @param id - The ID of the credential to reference
-* @returns A credential reference that will be resolved at push time
-*
-* @example
-* ```typescript
-* const apiKeyRef = credentialRef('api-key');
-*
-* const fetchDef = fetchDefinition({
-*   credential: apiKeyRef,
-*   // ...
-* });
-* ```
-*/
-function credentialRef(id) {
-	return {
-		__type: "credential-ref",
-		id
-	};
-}
-/**
-* Type guard to check if a value is a credential reference
-*/
-function isCredentialReference(value) {
-	return value && typeof value === "object" && value.__type === "credential-ref";
-}
-
-//#endregion
-//#region src/environment-settings.ts
-/**
-* Create a setting helper with TypeScript autocomplete
-*/
-function createEnvironmentSettings(environments) {
-	return {
-		getEnvironmentCredential: (key) => {
-			const currentEnv = process.env.INKEEP_ENV || "development";
-			const env = environments[currentEnv];
-			if (!env) throw new Error(`Environment '${currentEnv}' not found. Available: ${Object.keys(environments).join(", ")}`);
-			const credential$1 = env.credentials?.[key];
-			if (!credential$1) throw new Error(`Credential '${String(key)}' not found in environment '${currentEnv}'`);
-			return credential$1;
-		},
-		getEnvironmentMcp: (key) => {
-			const currentEnv = process.env.INKEEP_ENV || "development";
-			const env = environments[currentEnv];
-			if (!env) throw new Error(`Environment '${currentEnv}' not found. Available: ${Object.keys(environments).join(", ")}`);
-			const mcpServer$1 = env.mcpServers?.[key];
-			if (!mcpServer$1) throw new Error(`MCP Server '${String(key)}' not found in environment '${currentEnv}'`);
-			return mcpServer$1;
-		},
-		getEnvironmentSetting: (key) => {
-			const currentEnv = process.env.INKEEP_ENV || "development";
-			const env = environments[currentEnv];
-			if (!env) throw new Error(`Environment '${currentEnv}' not found. Available: ${Object.keys(environments).join(", ")}`);
-			const credential$1 = env.credentials?.[key];
-			if (!credential$1) throw new Error(`Credential '${String(key)}' not found in environment '${currentEnv}'`);
-			return credential$1;
-		}
-	};
-}
-/**
-* Create type-safe environment configurations
-*/
-function registerEnvironmentSettings(config) {
-	return config;
-}
-
-//#endregion
-//#region src/external-agent.ts
-const logger$1 = (0, __inkeep_agents_core.getLogger)("external-agent-builder");
-var ExternalAgent = class {
-	config;
-	type = "external";
-	initialized = false;
-	tenantId;
-	projectId;
-	baseURL;
-	constructor(config) {
-		this.config = {
-			...config,
-			type: "external"
-		};
-		this.tenantId = "default";
-		this.projectId = "default";
-		this.baseURL = this.config.baseUrl;
-		logger$1.debug({
-			externalAgentName: this.config.name,
-			baseUrl: this.config.baseUrl,
-			tenantId: this.tenantId
-		}, "External Agent constructor initialized");
-	}
-	/**
-	* Initialize the external agent by upserting it in the database
-	*/
-	async init() {
-		if (this.initialized) return;
-		try {
-			await this.upsertExternalAgent();
-			logger$1.info({ externalSubAgentId: this.getId() }, "External agent initialized successfully");
-			this.initialized = true;
-		} catch (error) {
-			logger$1.error({
-				externalSubAgentId: this.getId(),
-				error: error instanceof Error ? error.message : "Unknown error"
-			}, "Failed to initialize external agent");
-			throw error;
-		}
-	}
-	setContext(tenantId, projectId) {
-		this.tenantId = tenantId;
-		this.projectId = projectId;
-	}
-	getId() {
-		return this.config.id;
-	}
-	with(options) {
-		return {
-			externalAgent: this,
-			headers: options.headers
-		};
-	}
-	async upsertExternalAgent() {
-		const externalAgentData = {
-			id: this.getId(),
-			name: this.config.name,
-			description: this.config.description,
-			baseUrl: this.config.baseUrl,
-			credentialReferenceId: this.config.credentialReference?.id || void 0
-		};
-		const updateResponse = await fetch(`${this.baseURL}/tenants/${this.tenantId}/projects/${this.projectId}/external-agents/${this.getId()}`, {
-			method: "PUT",
-			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify(externalAgentData)
-		});
-		if (updateResponse.ok) {
-			logger$1.info({ externalSubAgentId: this.getId() }, "External agent updated successfully");
-			return;
-		}
-		if (updateResponse.status === 404) {
-			logger$1.info({ externalSubAgentId: this.getId() }, "External agent not found, creating new external agent");
-			const createResponse = await fetch(`${this.baseURL}/tenants/${this.tenantId}/projects/${this.projectId}/external-agents`, {
-				method: "POST",
-				headers: { "Content-Type": "application/json" },
-				body: JSON.stringify(externalAgentData)
-			});
-			if (!createResponse.ok) {
-				const errorText$1 = await createResponse.text().catch(() => "Unknown error");
-				throw new Error(`Failed to create external agent: ${createResponse.status} ${createResponse.statusText} - ${errorText$1}`);
-			}
-			logger$1.info({ externalSubAgentId: this.getId() }, "External agent created successfully");
-			return;
-		}
-		const errorText = await updateResponse.text().catch(() => "Unknown error");
-		throw new Error(`Failed to update external agent: ${updateResponse.status} ${updateResponse.statusText} - ${errorText}`);
-	}
-	/**
-	* Get the external agent configuration
-	*/
-	getConfig() {
-		return { ...this.config };
-	}
-	/**
-	* Get the external agent name
-	*/
-	getName() {
-		return this.config.name;
-	}
-	/**
-	* Get the external agent base URL
-	*/
-	getBaseUrl() {
-		return this.config.baseUrl;
-	}
-	/**
-	* Get the tenant ID
-	*/
-	getTenantId() {
-		return this.tenantId;
-	}
-	getDescription() {
-		return this.config.description || "";
-	}
-	getCredentialReferenceId() {
-		return this.config.credentialReference?.id || void 0;
-	}
-	getCredentialReference() {
-		return this.config.credentialReference || void 0;
-	}
-};
-/**
-* Factory function to create external agents - follows the same pattern as agent()
-*/
-function externalAgent(config) {
-	return new ExternalAgent(config);
-}
-/**
-* Helper function to create multiple external agents
-*/
-function externalAgents(configs) {
-	const builders = {};
-	for (const [name, config] of Object.entries(configs)) builders[name] = externalAgent(config);
-	return builders;
-}
-
-//#endregion
-//#region src/types.ts
-var AgentError = class extends Error {
-	constructor(message, code, details) {
-		super(message);
-		this.code = code;
-		this.details = details;
-		this.name = "AgentError";
-	}
-};
-var MaxTurnsExceededError = class extends AgentError {
-	constructor(maxTurns) {
-		super(`Maximum turns (${maxTurns}) exceeded`);
-		this.code = "MAX_TURNS_EXCEEDED";
-	}
-};
-
-//#endregion
-//#region src/runner.ts
-const logger = (0, __inkeep_agents_core.getLogger)("runner");
-var Runner = class Runner {
-	/**
-	* Run an agent until completion, handling transfers and tool calls
-	* Similar to OpenAI's Runner.run() pattern
-	* NOTE: This now requires an agent instead of an agent
-	*/
-	static async run(agent$1, messages, options) {
-		const maxTurns = options?.maxTurns || 10;
-		let turnCount = 0;
-		const messageHistory = Runner.normalizeToMessageHistory(messages);
-		const allToolCalls = [];
-		logger.info({
-			agentId: agent$1.getId(),
-			defaultSubAgent: agent$1.getDefaultSubAgent()?.getName(),
-			maxTurns,
-			initialMessageCount: messageHistory.length
-		}, "Starting agent run");
-		while (turnCount < maxTurns) {
-			logger.debug({
-				agentId: agent$1.getId(),
-				turnCount,
-				messageHistoryLength: messageHistory.length
-			}, "Starting turn");
-			const response = await agent$1.generate(messageHistory, options);
-			turnCount++;
-			logger.info({
-				agentId: agent$1.getId(),
-				turnCount,
-				responseLength: response.length
-			}, "Agent generation completed");
-			return {
-				finalOutput: response,
-				agent: agent$1.getDefaultSubAgent() || {},
-				turnCount,
-				usage: {
-					inputTokens: 0,
-					outputTokens: 0
-				},
-				metadata: {
-					toolCalls: allToolCalls,
-					transfers: []
-				}
-			};
-		}
-		logger.error({
-			agentId: agent$1.getId(),
-			maxTurns,
-			finalTurnCount: turnCount
-		}, "Maximum turns exceeded");
-		throw new MaxTurnsExceededError(maxTurns);
-	}
-	/**
-	* Stream an agent's response
-	*/
-	static async stream(agent$1, messages, options) {
-		logger.info({
-			agentId: agent$1.getId(),
-			defaultSubAgent: agent$1.getDefaultSubAgent()?.getName()
-		}, "Starting agent stream");
-		return agent$1.stream(messages, options);
-	}
-	/**
-	* Execute multiple agent in parallel and return the first successful result
-	*/
-	static async raceAgents(agent$1, messages, options) {
-		if (agent$1.length === 0) throw new Error("No agent provided for race");
-		logger.info({
-			agentCount: agent$1.length,
-			agentIds: agent$1.map((g) => g.getId())
-		}, "Starting agent race");
-		const promises = agent$1.map(async (agent$2, index) => {
-			try {
-				return {
-					...await Runner.run(agent$2, messages, options),
-					raceIndex: index
-				};
-			} catch (error) {
-				logger.error({
-					agentId: agent$2.getId(),
-					error: error instanceof Error ? error.message : "Unknown error"
-				}, "Agent failed in race");
-				throw error;
-			}
-		});
-		const result = await Promise.race(promises);
-		logger.info({
-			winningAgentId: result.agentId || "unknown",
-			raceIndex: result.raceIndex
-		}, "Agent race completed");
-		return result;
-	}
-	static normalizeToMessageHistory(messages) {
-		if (typeof messages === "string") return [{
-			role: "user",
-			content: messages
-		}];
-		if (Array.isArray(messages)) return messages.map((msg) => typeof msg === "string" ? {
-			role: "user",
-			content: msg
-		} : msg);
-		return [messages];
-	}
-	/**
-	* Validate agent configuration before running
-	*/
-	static validateAgent(agent$1) {
-		const errors = [];
-		if (!agent$1.getId()) errors.push("Agent ID is required");
-		const defaultSubAgent = agent$1.getDefaultSubAgent();
-		if (!defaultSubAgent) errors.push("Default agent is required");
-		else if (!defaultSubAgent.getName()) errors.push("Default agent name is required");
-		const subAgents = agent$1.getSubAgents();
-		if (subAgents.length === 0) errors.push("Agent must contain at least one subagent");
-		for (const subAgent$1 of subAgents) if (!subAgent$1.getName()) errors.push(`Agent missing name`);
-		return {
-			valid: errors.length === 0,
-			errors
-		};
-	}
-	/**
-	* Get execution statistics for an agent
-	*/
-	static async getExecutionStats(agent$1, messages, options) {
-		const subAgents = agent$1.getSubAgents();
-		const defaultSubAgent = agent$1.getDefaultSubAgent();
-		const messageCount = Array.isArray(messages) ? messages.length : 1;
-		return {
-			estimatedTurns: Math.min(Math.max(messageCount, 1), options?.maxTurns || 10),
-			estimatedTokens: messageCount * 100,
-			subAgentCount: subAgents.length,
-			defaultSubAgent: defaultSubAgent?.getName()
-		};
-	}
-};
-const run = Runner.run.bind(Runner);
-const stream = Runner.stream.bind(Runner);
-const raceAgents = Runner.raceAgents.bind(Runner);
-
-//#endregion
-//#region src/telemetry-provider.ts
-/**
-* TelemetryProvider - Abstraction for Telemetry/Observability
-*
-* This module provides a clean abstraction over telemetry implementations.
-* Cloud customers can use this without needing to install or configure
-* OpenTelemetry or Signoz directly.
-*
-* Telemetry is OPT-IN - if not configured, a no-op provider is used.
-*
-* @example
-* ```typescript
-* // Opt-in to telemetry with default console logger
-* import { InkeepTelemetryProvider, createConsoleTelemetryProvider } from '@inkeep/agents-sdk'
-*
-* const telemetry = createConsoleTelemetryProvider()
-*
-* // Or with OpenTelemetry (requires @opentelemetry packages)
-* const telemetry = createOpenTelemetryProvider({
-*   serviceName: 'my-agent',
-*   endpoint: 'http://localhost:4318'
-* })
-* ```
-*/
-/**
-* Span status codes
-*/
-const SpanStatus = {
-	OK: "ok",
-	ERROR: "error",
-	UNSET: "unset"
-};
-/**
-* No-op span implementation
-*/
-const createNoOpSpan = () => ({
-	setAttributes: function() {
-		return this;
-	},
-	setAttribute: function() {
-		return this;
-	},
-	recordException: function() {
-		return this;
-	},
-	setStatus: function() {
-		return this;
-	},
-	addEvent: function() {
-		return this;
-	},
-	end: () => {},
-	isRecording: () => false,
-	updateName: function() {
-		return this;
-	}
-});
-/**
-* No-op tracer implementation
-*/
-const createNoOpTracer = () => ({
-	startActiveSpan(_name, arg1, arg2) {
-		const fn = typeof arg1 === "function" ? arg1 : arg2;
-		if (!fn) throw new Error("No callback function provided");
-		return fn(createNoOpSpan());
-	},
-	startSpan(_name, _options) {
-		return createNoOpSpan();
-	}
-});
-/**
-* No-op logger implementation
-*/
-const createNoOpLogger = () => ({
-	debug: () => {},
-	info: () => {},
-	warn: () => {},
-	error: () => {}
-});
-/**
-* No-op metrics implementation
-*/
-const createNoOpMetrics = () => ({
-	increment: () => {},
-	gauge: () => {},
-	histogram: () => {}
-});
-/**
-* No-op telemetry provider (default)
-*/
-var NoOpTelemetryProvider = class {
-	getTracer(_name, _version) {
-		return createNoOpTracer();
-	}
-	getLogger(_name) {
-		return createNoOpLogger();
-	}
-	getMetrics(_name) {
-		return createNoOpMetrics();
-	}
-	async shutdown() {}
-	isEnabled() {
-		return false;
-	}
-};
-/**
-* Console-based telemetry provider for development/debugging
-*/
-var ConsoleTelemetryProvider = class {
-	serviceName;
-	constructor(serviceName = "inkeep-agent") {
-		this.serviceName = serviceName;
-	}
-	getTracer(name, _version) {
-		const serviceName = this.serviceName;
-		const createConsoleSpan = (spanName) => {
-			const startTime = Date.now();
-			const attributes = {};
-			const events = [];
-			return {
-				setAttributes: function(attrs) {
-					Object.assign(attributes, attrs);
-					return this;
-				},
-				setAttribute: function(key, value) {
-					attributes[key] = value;
-					return this;
-				},
-				recordException: function(error) {
-					console.error(`[${serviceName}:${name}] Exception in ${spanName}:`, error.message);
-					return this;
-				},
-				setStatus: function(status, message) {
-					if (status === SpanStatus.ERROR) console.error(`[${serviceName}:${name}] ${spanName} ERROR:`, message);
-					return this;
-				},
-				addEvent: function(eventName, eventAttrs) {
-					events.push({
-						name: eventName,
-						attributes: eventAttrs
-					});
-					return this;
-				},
-				end: () => {
-					const duration = Date.now() - startTime;
-					console.log(`[${serviceName}:${name}] ${spanName} completed in ${duration}ms`, {
-						attributes,
-						events
-					});
-				},
-				isRecording: () => true,
-				updateName: function(newName) {
-					console.log(`[${serviceName}:${name}] Span renamed: ${spanName} -> ${newName}`);
-					return this;
-				}
-			};
-		};
-		return {
-			startActiveSpan(spanName, arg1, arg2) {
-				const fn = typeof arg1 === "function" ? arg1 : arg2;
-				if (!fn) throw new Error("No callback function provided");
-				const span = createConsoleSpan(spanName);
-				try {
-					return fn(span);
-				} finally {
-					span.end();
-				}
-			},
-			startSpan(spanName, _options) {
-				return createConsoleSpan(spanName);
-			}
-		};
-	}
-	getLogger(name) {
-		const prefix = `[${this.serviceName}:${name}]`;
-		return {
-			debug: (message, context) => console.debug(prefix, message, context),
-			info: (message, context) => console.info(prefix, message, context),
-			warn: (message, context) => console.warn(prefix, message, context),
-			error: (message, context) => console.error(prefix, message, context)
-		};
-	}
-	getMetrics(name) {
-		const prefix = `[${this.serviceName}:${name}]`;
-		return {
-			increment: (metricName, value = 1, attributes) => console.log(`${prefix} COUNTER ${metricName}: +${value}`, attributes),
-			gauge: (metricName, value, attributes) => console.log(`${prefix} GAUGE ${metricName}: ${value}`, attributes),
-			histogram: (metricName, value, attributes) => console.log(`${prefix} HISTOGRAM ${metricName}: ${value}`, attributes)
-		};
-	}
-	async shutdown() {
-		console.log(`[${this.serviceName}] Telemetry provider shutting down`);
-	}
-	isEnabled() {
-		return true;
-	}
-};
-let globalProvider = new NoOpTelemetryProvider();
-/**
-* InkeepTelemetryProvider - Main telemetry management class
-*
-* Provides a unified interface for telemetry across the SDK.
-* Telemetry is OPT-IN - by default, a no-op provider is used.
-*/
-var InkeepTelemetryProvider = class {
-	provider;
-	constructor(config = {}) {
-		if (config.provider) this.provider = config.provider;
-		else if (config.enabled) this.provider = new ConsoleTelemetryProvider(config.serviceName);
-		else this.provider = new NoOpTelemetryProvider();
-	}
-	/**
-	* Get a tracer for creating spans
-	*/
-	getTracer(name, version) {
-		return this.provider.getTracer(name, version);
-	}
-	/**
-	* Get a logger for structured logging
-	*/
-	getLogger(name) {
-		return this.provider.getLogger(name);
-	}
-	/**
-	* Get metrics recorder
-	*/
-	getMetrics(name) {
-		return this.provider.getMetrics(name);
-	}
-	/**
-	* Check if telemetry is enabled
-	*/
-	isEnabled() {
-		return this.provider.isEnabled();
-	}
-	/**
-	* Shutdown the provider
-	*/
-	async shutdown() {
-		return this.provider.shutdown();
-	}
-	/**
-	* Get the underlying provider
-	*/
-	getProvider() {
-		return this.provider;
-	}
-	/**
-	* Set as the global telemetry provider
-	*/
-	setAsGlobal() {
-		globalProvider = this.provider;
-	}
-};
-/**
-* Get the global telemetry provider
-*/
-function getGlobalTelemetryProvider() {
-	return globalProvider;
-}
-/**
-* Set the global telemetry provider
-*/
-function setGlobalTelemetryProvider(provider) {
-	globalProvider = provider;
-}
-/**
-* Create a no-op telemetry provider (default, does nothing)
-*/
-function createNoOpTelemetryProvider() {
-	return new InkeepTelemetryProvider({ enabled: false });
-}
-/**
-* Create a console-based telemetry provider for development
-*/
-function createConsoleTelemetryProvider(serviceName) {
-	return new InkeepTelemetryProvider({
-		enabled: true,
-		serviceName,
-		provider: new ConsoleTelemetryProvider(serviceName)
-	});
-}
-/**
-* Wrap an OpenTelemetry span in our TelemetrySpan interface
-*/
-function wrapOtelSpan(otelSpan) {
-	return {
-		setAttributes: function(attributes) {
-			otelSpan.setAttributes(attributes);
-			return this;
-		},
-		setAttribute: function(key, value) {
-			otelSpan.setAttribute(key, value);
-			return this;
-		},
-		recordException: function(error) {
-			otelSpan.recordException(error);
-			return this;
-		},
-		setStatus: function(status, message) {
-			const statusCode = status === SpanStatus.ERROR ? 2 : status === SpanStatus.OK ? 1 : 0;
-			otelSpan.setStatus({
-				code: statusCode,
-				message
-			});
-			return this;
-		},
-		addEvent: function(name, attributes) {
-			otelSpan.addEvent(name, attributes);
-			return this;
-		},
-		end: () => otelSpan.end(),
-		isRecording: () => otelSpan.isRecording(),
-		updateName: function(name) {
-			otelSpan.updateName(name);
-			return this;
-		}
-	};
-}
-/**
-* Check if OpenTelemetry is available
-*/
-function isOpenTelemetryAvailable() {
-	try {
-		require.resolve("@opentelemetry/api");
-		return true;
-	} catch {
-		return false;
-	}
-}
-/**
-* Load OpenTelemetry module dynamically
-*/
-async function loadOpenTelemetryModule() {
-	return new Function("specifier", "return import(specifier)")("@opentelemetry/api");
-}
-/**
-* Create an OpenTelemetry-based provider
-*
-* Note: Requires @opentelemetry packages to be installed
-*/
-async function createOpenTelemetryProvider(config) {
-	if (!isOpenTelemetryAvailable()) {
-		console.warn("OpenTelemetry packages not installed. Install with: npm install @opentelemetry/api @opentelemetry/sdk-node");
-		return createNoOpTelemetryProvider();
-	}
-	try {
-		const { trace } = await loadOpenTelemetryModule();
-		return new InkeepTelemetryProvider({
-			enabled: true,
-			provider: {
-				getTracer(name, version) {
-					const otelTracer = trace.getTracer(name, version);
-					return {
-						startActiveSpan(spanName, arg1, arg2) {
-							const fn = typeof arg1 === "function" ? arg1 : arg2;
-							const options = typeof arg1 === "object" ? arg1 : void 0;
-							if (!fn) throw new Error("No callback function provided");
-							return otelTracer.startActiveSpan(spanName, options?.attributes ? { attributes: options.attributes } : {}, (otelSpan) => {
-								return fn(wrapOtelSpan(otelSpan));
-							});
-						},
-						startSpan(spanName, options) {
-							return wrapOtelSpan(otelTracer.startSpan(spanName, options?.attributes ? { attributes: options.attributes } : {}));
-						}
-					};
-				},
-				getLogger(name) {
-					return new ConsoleTelemetryProvider(config.serviceName).getLogger(name);
-				},
-				getMetrics(_name) {
-					return createNoOpMetrics();
-				},
-				async shutdown() {},
-				isEnabled() {
-					return true;
-				}
-			}
-		});
-	} catch (error) {
-		console.warn("Failed to initialize OpenTelemetry:", error instanceof Error ? error.message : "Unknown error");
-		return createNoOpTelemetryProvider();
-	}
-}
-
-//#endregion
-Object.defineProperty(exports, 'ANTHROPIC_MODELS', {
-  enumerable: true,
-  get: function () {
-    return __inkeep_agents_core.ANTHROPIC_MODELS;
-  }
-});
-exports.ArtifactComponent = ArtifactComponent;
-exports.ConsoleTelemetryProvider = ConsoleTelemetryProvider;
-exports.DataComponent = DataComponent;
-exports.ExternalAgent = ExternalAgent;
-exports.FunctionTool = FunctionTool;
-Object.defineProperty(exports, 'GOOGLE_MODELS', {
-  enumerable: true,
-  get: function () {
-    return __inkeep_agents_core.GOOGLE_MODELS;
-  }
-});
-exports.InkeepCredentialProvider = InkeepCredentialProvider;
-exports.InkeepTelemetryProvider = InkeepTelemetryProvider;
-exports.NoOpTelemetryProvider = NoOpTelemetryProvider;
-Object.defineProperty(exports, 'OPENAI_MODELS', {
-  enumerable: true,
-  get: function () {
-    return __inkeep_agents_core.OPENAI_MODELS;
-  }
-});
-exports.Project = Project;
-exports.Runner = Runner;
-exports.SpanStatus = SpanStatus;
-exports.StatusComponent = StatusComponent;
-exports.SubAgent = SubAgent;
-exports.Tool = Tool;
-exports.agent = agent;
-exports.agentMcp = agentMcp;
-exports.artifactComponent = artifactComponent;
-exports.createConsoleTelemetryProvider = createConsoleTelemetryProvider;
-exports.createCredentialProvider = createCredentialProvider;
-exports.createEnvironmentSettings = createEnvironmentSettings;
-exports.createFullProjectViaAPI = createFullProjectViaAPI;
-exports.createNoOpTelemetryProvider = createNoOpTelemetryProvider;
-exports.createOpenTelemetryProvider = createOpenTelemetryProvider;
-exports.credential = credential;
-exports.credentialRef = credentialRef;
-exports.dataComponent = dataComponent;
-exports.deleteFullProjectViaAPI = deleteFullProjectViaAPI;
-exports.externalAgent = externalAgent;
-exports.externalAgents = externalAgents;
-exports.functionTool = functionTool;
-exports.getFullProjectViaAPI = getFullProjectViaAPI;
-exports.getGlobalTelemetryProvider = getGlobalTelemetryProvider;
-exports.isCredentialReference = isCredentialReference;
-exports.mcpServer = mcpServer;
-exports.mcpTool = mcpTool;
-exports.project = project;
-exports.raceAgents = raceAgents;
-exports.registerEnvironmentSettings = registerEnvironmentSettings;
-exports.run = run;
-exports.setGlobalTelemetryProvider = setGlobalTelemetryProvider;
-exports.statusComponent = statusComponent;
-exports.stream = stream;
-exports.subAgent = subAgent;
-exports.transfer = transfer;
-exports.updateFullProjectViaAPI = updateFullProjectViaAPI;