@inkeep/agents-sdk 0.39.5 → 0.41.0

package/dist/agent.js

@@ -0,0 +1,720 @@
+import { getFullProjectViaAPI } from "./projectFullClient.js";
+import { updateFullAgentViaAPI } from "./agentFullClient.js";
+import { FunctionTool } from "./function-tool.js";
+import { getLogger } from "@inkeep/agents-core";
+import { convertZodToJsonSchema, isZodSchema } from "@inkeep/agents-core/utils/schema-conversion";
+
+//#region src/agent.ts
+const logger = getLogger("agent");
+function resolveGetter(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(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(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.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 of this.subAgents) {
+			if (subAgent.setContext) subAgent.setContext(tenantId, projectId, apiUrl);
+			const tools = subAgent.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.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 of this.subAgents) {
+			const transfers = subAgent.getTransfers();
+			const delegates = subAgent.getDelegates();
+			const tools = [];
+			const selectedToolsMapping = {};
+			const headersMapping = {};
+			const toolPoliciesMapping = {};
+			const subAgentTools = subAgent.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.getExternalAgentDelegates();
+			for (const externalAgentDelegate of subAgentExternalAgents) {
+				const externalAgent = externalAgentDelegate.externalAgent;
+				externalAgentsObject[externalAgent.getId()] = {
+					id: externalAgent.getId(),
+					name: externalAgent.getName(),
+					description: externalAgent.getDescription(),
+					baseUrl: externalAgent.getBaseUrl(),
+					credentialReferenceId: externalAgent.getCredentialReferenceId(),
+					type: "external"
+				};
+			}
+			const dataComponents = [];
+			const subAgentDataComponents = subAgent.getDataComponents();
+			if (subAgentDataComponents) for (const dataComponent of subAgentDataComponents) {
+				const dataComponentId = dataComponent.id || dataComponent.name.toLowerCase().replace(/\s+/g, "-");
+				dataComponents.push(dataComponentId);
+			}
+			const artifactComponents = [];
+			const subAgentArtifactComponents = subAgent.getArtifactComponents();
+			if (subAgentArtifactComponents) for (const artifactComponent of subAgentArtifactComponents) {
+				const artifactComponentId = artifactComponent.id || artifactComponent.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.getId()] = {
+				id: subAgent.getId(),
+				name: subAgent.getName(),
+				description: subAgent.config.description || "",
+				prompt: subAgent.getInstructions(),
+				models: subAgent.config.models,
+				stopWhen: subAgent.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 && isZodSchema(comp.detailsSchema)) {
+					const jsonSchema = 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 of this.subAgents) {
+			const subAgentTools = subAgent.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 = toolInstance;
+							agentToolsObject[toolId] = {
+								id: toolId,
+								name: toolInstance.getName(),
+								description: null,
+								config: {
+									type: "mcp",
+									mcp: {
+										server: { url: mcpTool.config.serverUrl },
+										transport: mcpTool.config.transport,
+										activeTools: mcpTool.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.info({ agentId: this.agentId }, "Initializing all tools in agent");
+		const toolInitPromises = [];
+		for (const subAgent of this.subAgents) {
+			const agentTools = subAgent.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.debug({
+							subAgentId: subAgent.getId(),
+							toolName,
+							toolType: toolInstance.constructor.name,
+							skipDbRegistration
+						}, "Tool initialized successfully");
+					} catch (error) {
+						logger.error({
+							subAgentId: subAgent.getId(),
+							toolName,
+							error: error instanceof Error ? error.message : "Unknown error"
+						}, "Failed to initialize tool");
+						throw error;
+					}
+				})());
+			}
+		}
+		await Promise.all(toolInitPromises);
+		logger.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.info({ agentId: this.agentId }, "Agent already initialized");
+			return;
+		}
+		logger.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.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.info({
+				agentId: this.agentId,
+				agentCount: Object.keys(createdAgent.subAgents || {}).length
+			}, "Agent initialized successfully using agent endpoint");
+			this.initialized = true;
+		} catch (error) {
+			logger.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.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.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.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.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.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.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 of this.subAgents) {
+			const name = subAgent.getName();
+			if (names.has(name)) errors.push(`Duplicate agent name: ${name}`);
+			names.add(name);
+		}
+		for (const subAgent of this.subAgents) {
+			const transfers = subAgent.getTransfers();
+			for (const transferAgent of transfers) if (!this.agentMap.has(transferAgent.getName())) errors.push(`Agent '${subAgent.getName()}' has transfer to '${transferAgent.getName()}' which is not in the agent`);
+			const delegates = subAgent.getDelegates();
+			for (const delegateAgent of delegates) if (this.isInternalAgent(delegateAgent)) {
+				if (!this.agentMap.has(delegateAgent.getName())) errors.push(`Agent '${subAgent.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.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.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 of this.subAgents) this.propagateModelSettingsToAgent(subAgent);
+	}
+	/**
+	* 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 of this.subAgents) {
+			if (!subAgent.config.stopWhen) subAgent.config.stopWhen = {};
+			if (subAgent.config.stopWhen.stepCountIs === void 0) subAgent.config.stopWhen.stepCountIs = projectStopWhen.stepCountIs;
+		}
+		logger.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 of this.subAgents) this.propagateModelSettingsToAgent(subAgent);
+	}
+	/**
+	* 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.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];
+	}
+};
+/**
+* Helper function to create agent - OpenAI style
+*/
+function agent(config) {
+	return new Agent(config);
+}
+/**
+* Factory function to create agent from configuration file
+*/
+async function generateAgent(configPath) {
+	logger.info({ configPath }, "Loading agent configuration");
+	try {
+		const config = await import(configPath);
+		const agentObject = agent(config.default || config);
+		await agentObject.init();
+		logger.info({
+			configPath,
+			agentId: agentObject.getStats().agentId,
+			agentCount: agentObject.getStats().agentCount
+		}, "Agent generated successfully");
+		return agentObject;
+	} catch (error) {
+		logger.error({
+			configPath,
+			error: error instanceof Error ? error.message : "Unknown error"
+		}, "Failed to generate agent from configuration");
+		throw error;
+	}
+}
+
+//#endregion
+export { Agent, agent, generateAgent };