@inkeep/agents-sdk 0.1.1 → 0.1.6

package/dist/graph.js

@@ -1,1294 +0,0 @@
-import { createDatabaseClient, getLogger, getProject } from '@inkeep/agents-core';
-import { ExternalAgent } from './externalAgent';
-import { updateFullGraphViaAPI } from './graphFullClient';
-const logger = getLogger('graph');
-// Helper function to resolve getter functions
-function resolveGetter(value) {
-    if (typeof value === 'function') {
-        return value();
-    }
-    return value;
-}
-export class AgentGraph {
-    agents = [];
-    agentMap = new Map();
-    defaultAgent;
-    baseURL;
-    tenantId;
-    projectId;
-    graphId;
-    graphName;
-    graphDescription;
-    initialized = false;
-    contextConfig; // ContextConfigBuilder
-    credentials;
-    models;
-    statusUpdateSettings;
-    graphPrompt;
-    stopWhen;
-    dbClient;
-    constructor(config) {
-        this.defaultAgent = config.defaultAgent;
-        this.tenantId = config.tenantId || 'default';
-        this.projectId = 'default'; // Default project ID, will be overridden by setConfig
-        this.graphId = config.id;
-        this.graphName = config.name || this.graphId;
-        this.graphDescription = 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;
-        // Initialize database client
-        // In test environment, always use in-memory database
-        const dbUrl = process.env.ENVIRONMENT === 'test'
-            ? ':memory:'
-            : process.env.DB_FILE_NAME || process.env.DATABASE_URL || ':memory:';
-        this.dbClient = createDatabaseClient({
-            url: dbUrl,
-        });
-        this.statusUpdateSettings = config.statusUpdates;
-        this.graphPrompt = config.graphPrompt;
-        // Set stopWhen - preserve original config or set default during inheritance
-        this.stopWhen = config.stopWhen
-            ? {
-                transferCountIs: config.stopWhen.transferCountIs,
-            }
-            : undefined;
-        this.agents = resolveGetter(config.agents) || [];
-        this.agentMap = new Map(this.agents.map((agent) => [agent.getId(), agent]));
-        // Add default agent to map
-        if (this.defaultAgent) {
-            this.agents.push(this.defaultAgent);
-            this.agentMap.set(this.defaultAgent.getId(), this.defaultAgent);
-        }
-        // Propagate graph-level models to agents immediately (if graph has models)
-        if (this.models) {
-            this.propagateImmediateModelSettings();
-        }
-        logger.info({
-            graphId: this.graphId,
-            tenantId: this.tenantId,
-            agentCount: this.agents.length,
-            defaultAgent: this.defaultAgent?.getName(),
-        }, 'AgentGraph 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 graph has been initialized');
-        }
-        this.tenantId = tenantId;
-        this.projectId = projectId;
-        this.baseURL = apiUrl;
-        // Propagate tenantId to all agents and their tools
-        for (const agent of this.agents) {
-            if (this.isInternalAgent(agent)) {
-                const internalAgent = agent;
-                if (!internalAgent.config.tenantId) {
-                    internalAgent.config.tenantId = tenantId;
-                }
-                // Also update tools in this agent
-                const tools = internalAgent.getTools();
-                for (const [_, toolInstance] of Object.entries(tools)) {
-                    if (toolInstance && typeof toolInstance === 'object' && toolInstance.config) {
-                        if (!toolInstance.config.tenantId) {
-                            toolInstance.config.tenantId = tenantId;
-                        }
-                        // Also update baseURL for tools if they have one
-                        if ('baseURL' in toolInstance && !toolInstance.baseURL) {
-                            toolInstance.baseURL = apiUrl;
-                        }
-                    }
-                }
-            }
-        }
-        // Update context config tenant ID if present
-        if (this.contextConfig && !this.contextConfig.tenantId) {
-            this.contextConfig.tenantId = tenantId;
-        }
-        logger.info({
-            graphId: this.graphId,
-            tenantId: this.tenantId,
-            projectId: this.projectId,
-            apiUrl: this.baseURL,
-        }, 'Graph configuration updated');
-    }
-    /**
-     * Convert the AgentGraph to FullGraphDefinition format for the new graph endpoint
-     */
-    async toFullGraphDefinition() {
-        const agentsObject = {};
-        for (const agent of this.agents) {
-            if (this.isInternalAgent(agent)) {
-                // Handle internal agents
-                const internalAgent = agent;
-                // Get agent relationships
-                const transfers = internalAgent.getTransfers();
-                const delegates = internalAgent.getDelegates();
-                // Convert tools to the expected format (agent.tools should be an array of tool IDs)
-                const tools = [];
-                const agentTools = internalAgent.getTools();
-                for (const [toolName, toolInstance] of Object.entries(agentTools)) {
-                    if (toolInstance && typeof toolInstance === 'object') {
-                        const toolId = toolInstance.getId?.() || toolInstance.id || toolName;
-                        tools.push(toolId);
-                    }
-                }
-                // Convert dataComponents to the expected format (agent.dataComponents should be an array of dataComponent IDs)
-                const dataComponents = [];
-                const agentDataComponents = internalAgent.getDataComponents();
-                if (agentDataComponents) {
-                    for (const dataComponent of agentDataComponents) {
-                        const dataComponentId = dataComponent.id || dataComponent.name.toLowerCase().replace(/\s+/g, '-');
-                        dataComponents.push(dataComponentId);
-                    }
-                }
-                // Convert artifactComponents to the expected format (agent.artifactComponents should be an array of artifactComponent IDs)
-                const artifactComponents = [];
-                const agentArtifactComponents = internalAgent.getArtifactComponents();
-                if (agentArtifactComponents) {
-                    for (const artifactComponent of agentArtifactComponents) {
-                        const artifactComponentId = artifactComponent.id || artifactComponent.name.toLowerCase().replace(/\s+/g, '-');
-                        artifactComponents.push(artifactComponentId);
-                    }
-                }
-                agentsObject[internalAgent.getId()] = {
-                    id: internalAgent.getId(),
-                    name: internalAgent.getName(),
-                    description: internalAgent.config.description || `Agent ${internalAgent.getName()}`,
-                    prompt: internalAgent.getInstructions(),
-                    models: internalAgent.config.models,
-                    canTransferTo: transfers.map((h) => h.getId()),
-                    canDelegateTo: delegates.map((d) => d.getId()),
-                    tools,
-                    dataComponents: dataComponents.length > 0 ? dataComponents : undefined,
-                    artifactComponents: artifactComponents.length > 0 ? artifactComponents : undefined,
-                    type: 'internal',
-                };
-            }
-            else {
-                // Handle external agents
-                const externalAgent = agent;
-                agentsObject[externalAgent.getId()] = {
-                    id: externalAgent.getId(),
-                    name: externalAgent.getName(),
-                    description: externalAgent.getDescription(),
-                    baseUrl: externalAgent.getBaseUrl(),
-                    credentialReferenceId: externalAgent.getCredentialReferenceId(),
-                    headers: externalAgent.getHeaders(),
-                    tools: [], // External agents don't have tools in this context
-                    type: 'external',
-                };
-            }
-        }
-        // Collect all tools from all agents
-        const toolsObject = {};
-        for (const agent of this.agents) {
-            if (!agent.getTransfers) {
-                continue; // Skip external agents
-            }
-            const internalAgent = agent;
-            const agentTools = internalAgent.getTools();
-            for (const [toolName, toolInstance] of Object.entries(agentTools)) {
-                if (toolInstance && typeof toolInstance === 'object') {
-                    const toolId = toolInstance.getId?.() || toolInstance.id || toolName;
-                    // Only add if not already added (avoid duplicates across agents)
-                    if (!toolsObject[toolId]) {
-                        let toolConfig;
-                        // Check if it's an IPCTool with MCP server configuration
-                        if (toolInstance.config?.serverUrl) {
-                            toolConfig = {
-                                type: 'mcp',
-                                mcp: {
-                                    server: {
-                                        url: toolInstance.config.serverUrl,
-                                    },
-                                },
-                            };
-                        }
-                        else if (toolInstance.config?.type === 'mcp') {
-                            // Already has proper MCP config
-                            toolConfig = toolInstance.config;
-                        }
-                        else {
-                            // Fallback for function tools or uninitialized tools
-                            toolConfig = {
-                                type: 'function',
-                                parameters: toolInstance.parameters || {},
-                            };
-                        }
-                        const toolData = {
-                            id: toolId,
-                            name: toolInstance.config?.name || toolInstance.name || toolName,
-                            config: toolConfig,
-                            status: toolInstance.getStatus?.() || toolInstance.status || 'unknown',
-                        };
-                        // Add additional fields if available
-                        if (toolInstance.config?.imageUrl) {
-                            toolData.imageUrl = toolInstance.config.imageUrl;
-                        }
-                        if (toolInstance.config?.headers) {
-                            toolData.headers = toolInstance.config.headers;
-                        }
-                        if (toolInstance.capabilities) {
-                            toolData.capabilities = toolInstance.capabilities;
-                        }
-                        if (toolInstance.lastHealthCheck) {
-                            toolData.lastHealthCheck = toolInstance.lastHealthCheck;
-                        }
-                        if (toolInstance.availableTools) {
-                            toolData.availableTools = toolInstance.availableTools;
-                        }
-                        if (toolInstance.lastError) {
-                            toolData.lastError = toolInstance.lastError;
-                        }
-                        if (toolInstance.lastToolsSync) {
-                            toolData.lastToolsSync = toolInstance.lastToolsSync;
-                        }
-                        // Add credential reference ID if available
-                        if (toolInstance.getCredentialReferenceId?.()) {
-                            toolData.credentialReferenceId = toolInstance.getCredentialReferenceId();
-                        }
-                        toolsObject[toolId] = toolData;
-                    }
-                }
-            }
-        }
-        // Collect all dataComponents from all agents
-        const dataComponentsObject = {};
-        for (const agent of this.agents) {
-            if (!this.isInternalAgent(agent)) {
-                continue; // Skip external agents
-            }
-            const internalAgent = agent;
-            const agentDataComponents = internalAgent.getDataComponents();
-            if (agentDataComponents) {
-                for (const dataComponent of agentDataComponents) {
-                    const dataComponentId = dataComponent.id || dataComponent.name.toLowerCase().replace(/\s+/g, '-');
-                    // Only add if not already added (avoid duplicates across agents)
-                    if (!dataComponentsObject[dataComponentId]) {
-                        dataComponentsObject[dataComponentId] = {
-                            id: dataComponentId,
-                            name: dataComponent.name,
-                            description: dataComponent.description || '',
-                            props: dataComponent.props || {},
-                        };
-                    }
-                }
-            }
-        }
-        // Collect all artifactComponents from all agents
-        const artifactComponentsObject = {};
-        for (const agent of this.agents) {
-            if (!this.isInternalAgent(agent)) {
-                continue; // Skip external agents
-            }
-            const internalAgent = agent;
-            const agentArtifactComponents = internalAgent.getArtifactComponents();
-            if (agentArtifactComponents) {
-                for (const artifactComponent of agentArtifactComponents) {
-                    const artifactComponentId = artifactComponent.id || artifactComponent.name.toLowerCase().replace(/\s+/g, '-');
-                    // Only add if not already added (avoid duplicates across agents)
-                    if (!artifactComponentsObject[artifactComponentId]) {
-                        artifactComponentsObject[artifactComponentId] = {
-                            id: artifactComponentId,
-                            name: artifactComponent.name,
-                            description: artifactComponent.description || '',
-                            summaryProps: artifactComponent.summaryProps || {},
-                            fullProps: artifactComponent.fullProps || {},
-                        };
-                    }
-                }
-            }
-        }
-        return {
-            id: this.graphId,
-            name: this.graphName,
-            description: this.graphDescription,
-            defaultAgentId: this.defaultAgent?.getId() || '',
-            agents: agentsObject,
-            tools: toolsObject,
-            contextConfig: this.contextConfig?.toObject(),
-            credentialReferences: this.credentials?.map((credentialReference) => ({
-                type: credentialReference.type,
-                id: credentialReference.id,
-                credentialStoreId: credentialReference.credentialStoreId,
-                retrievalParams: credentialReference.retrievalParams || {},
-            })),
-            models: this.models,
-            statusUpdates: this.statusUpdateSettings,
-            graphPrompt: this.graphPrompt,
-            dataComponents: Object.keys(dataComponentsObject).length > 0 ? dataComponentsObject : undefined,
-            artifactComponents: Object.keys(artifactComponentsObject).length > 0 ? artifactComponentsObject : undefined,
-            createdAt: new Date().toISOString(),
-            updatedAt: new Date().toISOString(),
-        };
-    }
-    /**
-     * Initialize all tools in all agents (especially IPCTools that need MCP server URLs)
-     */
-    async initializeAllTools() {
-        logger.info({ graphId: this.graphId }, 'Initializing all tools in graph');
-        const toolInitPromises = [];
-        for (const agent of this.agents) {
-            // Skip external agents as they don't have getTools method
-            if (!agent.getTools) {
-                continue;
-            }
-            const internalAgent = agent;
-            const agentTools = internalAgent.getTools();
-            for (const [toolName, toolInstance] of Object.entries(agentTools)) {
-                if (toolInstance && typeof toolInstance === 'object') {
-                    // Check if this is a tool that needs initialization
-                    if (typeof toolInstance.init === 'function') {
-                        toolInitPromises.push((async () => {
-                            try {
-                                // Skip database registration for all tools since graphFull will handle it
-                                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({
-                                    agentId: agent.getId(),
-                                    toolName,
-                                    toolType: toolInstance.constructor.name,
-                                    skipDbRegistration,
-                                }, 'Tool initialized successfully');
-                            }
-                            catch (error) {
-                                logger.error({
-                                    agentId: agent.getId(),
-                                    toolName,
-                                    error: error instanceof Error ? error.message : 'Unknown error',
-                                }, 'Failed to initialize tool');
-                                throw error;
-                            }
-                        })());
-                    }
-                }
-            }
-        }
-        await Promise.all(toolInitPromises);
-        logger.info({ graphId: this.graphId, toolCount: toolInitPromises.length }, 'All tools initialized successfully');
-    }
-    /**
-     * Initialize the graph and all agents in the backend using the new graph endpoint
-     */
-    async init() {
-        if (this.initialized) {
-            logger.info({ graphId: this.graphId }, 'Graph already initialized');
-            return;
-        }
-        logger.info({
-            graphId: this.graphId,
-            agentCount: this.agents.length,
-        }, 'Initializing agent graph using new graph endpoint');
-        try {
-            // Initialize all tools first (especially IPCTools that need MCP server URLs)
-            await this.initializeAllTools();
-            // Apply model inheritance hierarchy (Project -> Graph -> Agent)
-            await this.applyModelInheritance();
-            // Convert to FullGraphDefinition format
-            const graphDefinition = await this.toFullGraphDefinition();
-            // Always use API mode (baseURL is always set)
-            logger.info({
-                graphId: this.graphId,
-                mode: 'api-client',
-                apiUrl: this.baseURL,
-            }, 'Using API client to create/update graph');
-            // Try update first (upsert behavior)
-            const createdGraph = await updateFullGraphViaAPI(this.tenantId, this.projectId, this.baseURL, this.graphId, graphDefinition);
-            logger.info({
-                graphId: this.graphId,
-                agentCount: Object.keys(createdGraph.agents || {}).length,
-            }, 'Agent graph initialized successfully using graph endpoint');
-            this.initialized = true;
-        }
-        catch (error) {
-            logger.error({
-                graphId: this.graphId,
-                error: error instanceof Error ? error.message : 'Unknown error',
-            }, 'Failed to initialize agent graph using graph endpoint');
-            throw error;
-        }
-    }
-    /**
-     * Legacy initialization method - kept for backward compatibility
-     * Initialize the graph and all agents in the backend using individual endpoints
-     */
-    async initLegacy() {
-        if (this.initialized) {
-            logger.info({ graphId: this.graphId }, 'Graph already initialized');
-            return;
-        }
-        logger.info({
-            graphId: this.graphId,
-            agentCount: this.agents.length,
-        }, 'Initializing agent graph');
-        try {
-            // Component mode has been removed
-            // Step 2: Initialize context configuration if provided
-            if (this.contextConfig) {
-                await this.contextConfig.init();
-                logger.info({
-                    graphId: this.graphId,
-                    contextConfigId: this.contextConfig.getId(),
-                }, 'Context configuration initialized for graph');
-            }
-            // Step 3: Initialize all agents
-            const initPromises = this.agents.map(async (agent) => {
-                try {
-                    // Set the graphId on the agent config before initialization
-                    agent.config.graphId = this.graphId;
-                    await agent.init();
-                    logger.debug({
-                        agentId: agent.getId(),
-                        graphId: this.graphId,
-                    }, 'Agent initialized in graph');
-                }
-                catch (error) {
-                    logger.error({
-                        agentId: agent.getId(),
-                        graphId: this.graphId,
-                        error: error instanceof Error ? error.message : 'Unknown error',
-                    }, 'Failed to initialize agent in graph');
-                    throw error;
-                }
-            });
-            await Promise.all(initPromises);
-            // Step 2: Create agent graph in database (now that agents exist)
-            await this.saveToDatabase();
-            // Step 3: Create external agents in database
-            await this.createExternalAgents();
-            // Step 4: Create agent relations (transfer and delegation) using the graph's graphId
-            await this.createAgentRelations();
-            // Step 5: Set up graph-level relationships
-            await this.saveRelations();
-            this.initialized = true;
-            logger.info({
-                graphId: this.graphId,
-                agentCount: this.agents.length,
-            }, 'Agent graph initialized successfully');
-        }
-        catch (error) {
-            logger.error({
-                graphId: this.graphId,
-                error: error instanceof Error ? error.message : 'Unknown error',
-            }, 'Failed to initialize agent graph');
-            throw error;
-        }
-    }
-    /**
-     * Generate a response using the default agent
-     */
-    async generate(input, options) {
-        await this._init();
-        if (!this.defaultAgent) {
-            throw new Error('No default agent configured for this graph');
-        }
-        logger.info({
-            graphId: this.graphId,
-            defaultAgent: this.defaultAgent.getName(),
-            conversationId: options?.conversationId,
-        }, 'Generating response with default agent');
-        // Use the proper backend execution instead of the local runner
-        const response = await this.executeWithBackend(input, options);
-        return response;
-    }
-    /**
-     * Stream a response using the default agent
-     */
-    async stream(input, options) {
-        await this._init();
-        if (!this.defaultAgent) {
-            throw new Error('No default agent configured for this graph');
-        }
-        logger.info({
-            graphId: this.graphId,
-            defaultAgent: this.defaultAgent.getName(),
-            conversationId: options?.conversationId,
-        }, 'Streaming response with default agent');
-        // Delegate to the graph's stream method with backend
-        // For now, create a simple async generator that yields the response
-        const textStream = async function* (graph) {
-            const response = await graph.executeWithBackend(input, options);
-            // Simulate streaming by yielding chunks
-            const words = response.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 graph
-     */
-    async runWith(agentId, input, options) {
-        await this._init();
-        const agent = this.getAgent(agentId);
-        if (!agent) {
-            throw new Error(`Agent '${agentId}' not found in graph`);
-        }
-        // Only internal agents can be run directly via this method
-        if (!this.isInternalAgent(agent)) {
-            throw new Error(`Agent '${agentId}' is an external agent and cannot be run directly. External agents are only accessible via delegation.`);
-        }
-        logger.info({
-            graphId: this.graphId,
-            agentId,
-            conversationId: options?.conversationId,
-        }, 'Running with specific agent');
-        // Use backend execution and wrap result in RunResult format
-        const response = await this.executeWithBackend(input, options);
-        return {
-            finalOutput: response,
-            agent: agent,
-            turnCount: 1,
-            usage: { inputTokens: 0, outputTokens: 0 },
-            metadata: {
-                toolCalls: [],
-                transfers: [],
-            },
-        };
-    }
-    /**
-     * Get an agent by name (unified method for all agent types)
-     */
-    getAgent(name) {
-        return this.agentMap.get(name);
-    }
-    /**
-     * Add an agent to the graph
-     */
-    addAgent(agent) {
-        this.agents.push(agent);
-        this.agentMap.set(agent.getId(), agent);
-        // Apply immediate model inheritance if graph has models
-        if (this.models && this.isInternalAgent(agent)) {
-            this.propagateModelSettingsToAgent(agent);
-        }
-        logger.info({
-            graphId: this.graphId,
-            agentId: agent.getId(),
-            agentType: this.isInternalAgent(agent) ? 'internal' : 'external',
-        }, 'Agent added to graph');
-    }
-    /**
-     * Remove an agent from the graph
-     */
-    removeAgent(id) {
-        const agentToRemove = this.agentMap.get(id);
-        if (agentToRemove) {
-            this.agentMap.delete(agentToRemove.getId());
-            this.agents = this.agents.filter((agent) => agent.getId() !== agentToRemove.getId());
-            logger.info({
-                graphId: this.graphId,
-                agentId: agentToRemove.getId(),
-            }, 'Agent removed from graph');
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Get all agents in the graph
-     */
-    getAgents() {
-        return this.agents;
-    }
-    /**
-     * Get all agent ids (unified method for all agent types)
-     */
-    getAgentIds() {
-        return Array.from(this.agentMap.keys());
-    }
-    /**
-     * Set the default agent
-     */
-    setDefaultAgent(agent) {
-        this.defaultAgent = agent;
-        this.addAgent(agent); // Ensure it's in the graph
-        logger.info({
-            graphId: this.graphId,
-            defaultAgent: agent.getId(),
-        }, 'Default agent updated');
-    }
-    /**
-     * Get the default agent
-     */
-    getDefaultAgent() {
-        return this.defaultAgent;
-    }
-    /**
-     * Get the graph ID
-     */
-    getId() {
-        return this.graphId;
-    }
-    getName() {
-        return this.graphName;
-    }
-    getDescription() {
-        return this.graphDescription;
-    }
-    getTenantId() {
-        return this.tenantId;
-    }
-    /**
-     * Get the graph's model settingsuration
-     */
-    getModels() {
-        return this.models;
-    }
-    /**
-     * Set the graph's model settingsuration
-     */
-    setModels(models) {
-        this.models = models;
-    }
-    /**
-     * Get the graph's prompt configuration
-     */
-    getGraphPrompt() {
-        return this.graphPrompt;
-    }
-    /**
-     * Get the graph's stopWhen configuration
-     */
-    getStopWhen() {
-        return this.stopWhen || { transferCountIs: 10 };
-    }
-    /**
-     * Get the graph's status updates configuration
-     */
-    getStatusUpdateSettings() {
-        return this.statusUpdateSettings;
-    }
-    /**
-     * Get the summarizer model from the graph's model settings
-     */
-    getSummarizerModel() {
-        return this.models?.summarizer;
-    }
-    /**
-     * Get graph statistics
-     */
-    getStats() {
-        return {
-            agentCount: this.agents.length,
-            defaultAgent: this.defaultAgent?.getName() || null,
-            initialized: this.initialized,
-            graphId: this.graphId,
-            tenantId: this.tenantId,
-        };
-    }
-    /**
-     * Validate the graph configuration
-     */
-    validate() {
-        const errors = [];
-        if (this.agents.length === 0) {
-            errors.push('Graph must contain at least one agent');
-        }
-        if (!this.defaultAgent) {
-            errors.push('Graph must have a default agent');
-        }
-        // Validate agent names are unique
-        const names = new Set();
-        for (const agent of this.agents) {
-            const name = agent.getName();
-            if (names.has(name)) {
-                errors.push(`Duplicate agent name: ${name}`);
-            }
-            names.add(name);
-        }
-        // Validate agent relationships (transfer and delegation) for internal agents only
-        for (const agent of this.agents) {
-            if (!this.isInternalAgent(agent))
-                continue; // Skip external agents for relationship validation
-            // Validate transfer relationships
-            const transfers = agent.getTransfers();
-            for (const transferAgent of transfers) {
-                if (!this.agentMap.has(transferAgent.getName())) {
-                    errors.push(`Agent '${agent.getName()}' has transfer to '${transferAgent.getName()}' which is not in the graph`);
-                }
-            }
-            // Validate delegation relationships
-            const delegates = agent.getDelegates();
-            for (const delegateAgent of delegates) {
-                if (!this.agentMap.has(delegateAgent.getName())) {
-                    errors.push(`Agent '${agent.getName()}' has delegation to '${delegateAgent.getName()}' which is not in the graph`);
-                }
-            }
-        }
-        return {
-            valid: errors.length === 0,
-            errors,
-        };
-    }
-    // Private helper methods
-    async _init() {
-        if (!this.initialized) {
-            await this.init();
-        }
-    }
-    /**
-     * Type guard to check if an agent is an internal AgentInterface
-     */
-    isInternalAgent(agent) {
-        // Internal agents have getTransfers, getDelegates, and other AgentInterface methods
-        // External agents only have basic identification methods
-        return 'getTransfers' in agent && typeof agent.getTransfers === 'function';
-    }
-    /**
-     * Get project-level model settingsuration defaults
-     */
-    async getProjectModelDefaults() {
-        try {
-            const project = await getProject(this.dbClient)({
-                scopes: { tenantId: this.tenantId, projectId: this.projectId },
-            });
-            return project?.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 undefined;
-        }
-    }
-    /**
-     * Get project-level stopWhen configuration defaults
-     */
-    async getProjectStopWhenDefaults() {
-        try {
-            const project = await getProject(this.dbClient)({
-                scopes: { tenantId: this.tenantId, projectId: this.projectId },
-            });
-            return project?.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 undefined;
-        }
-    }
-    /**
-     * Apply model inheritance hierarchy: Project -> Graph -> Agent
-     */
-    async applyModelInheritance() {
-        // Always get project defaults to check for partial inheritance
-        const projectModels = await this.getProjectModelDefaults();
-        if (projectModels) {
-            // Initialize models object if it doesn't exist
-            if (!this.models) {
-                this.models = {};
-            }
-            // Inherit individual model types from project if not set at graph level
-            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;
-            }
-        }
-        // Apply stopWhen inheritance: Project -> Graph -> Agent
-        await this.applyStopWhenInheritance();
-        // Propagate to agents
-        for (const agent of this.agents) {
-            if (this.isInternalAgent(agent)) {
-                this.propagateModelSettingsToAgent(agent);
-            }
-        }
-    }
-    /**
-     * Apply stopWhen inheritance hierarchy: Project -> Graph -> Agent
-     */
-    async applyStopWhenInheritance() {
-        // Get project stopWhen defaults
-        const projectStopWhen = await this.getProjectStopWhenDefaults();
-        // Initialize stopWhen if it doesn't exist (graph had no stopWhen config)
-        if (!this.stopWhen) {
-            this.stopWhen = {};
-        }
-        // Inherit transferCountIs from project if graph doesn't have it explicitly set
-        if (this.stopWhen.transferCountIs === undefined &&
-            projectStopWhen?.transferCountIs !== undefined) {
-            this.stopWhen.transferCountIs = projectStopWhen.transferCountIs;
-        }
-        // Set default transferCountIs if still not set
-        if (this.stopWhen.transferCountIs === undefined) {
-            this.stopWhen.transferCountIs = 10;
-        }
-        // Propagate stepCountIs from project to agents
-        if (projectStopWhen?.stepCountIs !== undefined) {
-            for (const agent of this.agents) {
-                if (this.isInternalAgent(agent)) {
-                    const internalAgent = agent;
-                    // Initialize agent stopWhen if it doesn't exist
-                    if (!internalAgent.config.stopWhen) {
-                        internalAgent.config.stopWhen = {};
-                    }
-                    // Inherit stepCountIs from project if not set at agent level
-                    if (internalAgent.config.stopWhen.stepCountIs === undefined) {
-                        internalAgent.config.stopWhen.stepCountIs = projectStopWhen.stepCountIs;
-                    }
-                }
-            }
-        }
-        logger.debug({
-            graphId: this.graphId,
-            graphStopWhen: this.stopWhen,
-            projectStopWhen,
-        }, 'Applied stopWhen inheritance from project to graph');
-    }
-    /**
-     * Propagate graph-level model settings to agents (supporting partial inheritance)
-     */
-    propagateModelSettingsToAgent(agent) {
-        if (this.models) {
-            // Initialize agent models if they don't exist
-            if (!agent.config.models) {
-                agent.config.models = {};
-            }
-            // Inherit individual model types from graph if not set at agent level
-            if (!agent.config.models.base && this.models.base) {
-                agent.config.models.base = this.models.base;
-            }
-            if (!agent.config.models.structuredOutput && this.models.structuredOutput) {
-                agent.config.models.structuredOutput = this.models.structuredOutput;
-            }
-            if (!agent.config.models.summarizer && this.models.summarizer) {
-                agent.config.models.summarizer = this.models.summarizer;
-            }
-        }
-    }
-    /**
-     * Immediately propagate graph-level models to all agents during construction
-     */
-    propagateImmediateModelSettings() {
-        for (const agent of this.agents) {
-            if (this.isInternalAgent(agent)) {
-                this.propagateModelSettingsToAgent(agent);
-            }
-        }
-    }
-    /**
-     * Type guard to check if an agent is an external AgentInterface
-     */
-    isExternalAgent(agent) {
-        return !this.isInternalAgent(agent);
-    }
-    /**
-     * 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}/graphs/${this.graphId}/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,
-            // Include conversationId for multi-turn support
-            ...(options?.conversationId && { conversationId: options.conversationId }),
-            // Include context data if available
-            ...(options?.customBodyParams && { ...options.customBodyParams }),
-            stream: false, // Explicitly disable streaming - must come after options to override
-        };
-        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();
-            // Check if response is SSE format (starts with "data:")
-            if (responseText.startsWith('data:')) {
-                // Parse SSE response
-                return this.parseStreamingResponse(responseText);
-            }
-            // Parse regular JSON response
-            const data = JSON.parse(responseText);
-            return data.result || data.choices?.[0]?.message?.content || '';
-        }
-        catch (error) {
-            throw new Error(`Graph 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); // Remove 'data: ' prefix
-                if (dataStr === '[DONE]')
-                    break;
-                try {
-                    const data = JSON.parse(dataStr);
-                    const delta = data.choices?.[0]?.delta?.content;
-                    if (delta) {
-                        content += delta;
-                    }
-                }
-                catch (e) {
-                    // Skip invalid JSON lines
-                }
-            }
-        }
-        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];
-    }
-    async saveToDatabase() {
-        try {
-            // Check if graph already exists
-            const getUrl = `${this.baseURL}/tenants/${this.tenantId}/crud/agent-graphs/${this.graphId}`;
-            try {
-                const getResponse = await fetch(getUrl, {
-                    method: 'GET',
-                    headers: {
-                        'Content-Type': 'application/json',
-                    },
-                });
-                if (getResponse.ok) {
-                    logger.info({ graphId: this.graphId }, 'Graph already exists in backend');
-                    return;
-                }
-                if (getResponse.status !== 404) {
-                    throw new Error(`HTTP ${getResponse.status}: ${getResponse.statusText}`);
-                }
-            }
-            catch (error) {
-                if (!error.message.includes('404')) {
-                    throw error;
-                }
-            }
-            // Graph doesn't exist, create it
-            logger.info({ graphId: this.graphId }, 'Creating graph in backend');
-            const createUrl = `${this.baseURL}/tenants/${this.tenantId}/crud/agent-graphs`;
-            const createResponse = await fetch(createUrl, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({
-                    id: this.graphId,
-                    name: this.graphName,
-                    defaultAgentId: this.defaultAgent?.getId() || '',
-                    contextConfigId: this.contextConfig?.getId(),
-                    models: this.models,
-                }),
-            });
-            if (!createResponse.ok) {
-                throw new Error(`HTTP ${createResponse.status}: ${createResponse.statusText}`);
-            }
-            const createData = (await createResponse.json());
-            this.graphId = createData.data.id;
-            logger.info({ graph: createData.data }, 'Graph created in backend');
-        }
-        catch (error) {
-            throw new Error(`Failed to save graph to database: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-    async saveRelations() {
-        if (this.defaultAgent) {
-            try {
-                const updateUrl = `${this.baseURL}/tenants/${this.tenantId}/crud/agent-graphs/${this.graphId}`;
-                const updateResponse = await fetch(updateUrl, {
-                    method: 'PUT',
-                    headers: {
-                        'Content-Type': 'application/json',
-                    },
-                    body: JSON.stringify({
-                        id: this.graphId,
-                        defaultAgentId: this.defaultAgent.getId(),
-                        contextConfigId: this.contextConfig?.getId(),
-                    }),
-                });
-                if (!updateResponse.ok) {
-                    throw new Error(`HTTP ${updateResponse.status}: ${updateResponse.statusText}`);
-                }
-                logger.debug({
-                    graphId: this.graphId,
-                    defaultAgent: this.defaultAgent.getName(),
-                }, 'Graph relationships configured');
-            }
-            catch (error) {
-                logger.error({
-                    graphId: this.graphId,
-                    error: error instanceof Error ? error.message : 'Unknown error',
-                }, 'Failed to update graph relationships');
-                throw error;
-            }
-        }
-    }
-    async createAgentRelations() {
-        // Create both transfer and delegation relations for all agents now that they have graphId
-        const allRelationPromises = [];
-        // Collect all relation creation promises from all agents
-        for (const agent of this.agents) {
-            if (this.isInternalAgent(agent)) {
-                // Create internal transfer relations
-                const transfers = agent.getTransfers();
-                for (const transferAgent of transfers) {
-                    allRelationPromises.push(this.createInternalAgentRelation(agent, transferAgent, 'transfer'));
-                }
-                // Create internal delegation relations
-                const delegates = agent.getDelegates();
-                for (const delegate of delegates) {
-                    // Check if delegate is an ExternalAgent instance
-                    if (delegate instanceof ExternalAgent) {
-                        allRelationPromises.push(this.createExternalAgentRelation(agent, delegate, 'delegate'));
-                    }
-                    else {
-                        // Must be an internal agent (AgentInterface)
-                        allRelationPromises.push(this.createInternalAgentRelation(agent, delegate, 'delegate'));
-                    }
-                }
-            }
-        }
-        // Use Promise.allSettled for better error handling - allows all operations to complete
-        const results = await Promise.allSettled(allRelationPromises);
-        // Log and collect errors without failing the entire operation
-        const errors = [];
-        let successCount = 0;
-        for (const result of results) {
-            if (result.status === 'fulfilled') {
-                successCount++;
-            }
-            else {
-                errors.push(result.reason);
-                logger.error({
-                    error: result.reason instanceof Error ? result.reason.message : 'Unknown error',
-                    graphId: this.graphId,
-                }, 'Failed to create agent relation');
-            }
-        }
-        logger.info({
-            graphId: this.graphId,
-            totalRelations: allRelationPromises.length,
-            successCount,
-            errorCount: errors.length,
-        }, 'Completed agent relation creation batch');
-        // Only throw if ALL relations failed, allowing partial success
-        if (errors.length > 0 && successCount === 0) {
-            throw new Error(`All ${errors.length} agent relation creations failed`);
-        }
-    }
-    async createInternalAgentRelation(sourceAgent, targetAgent, relationType) {
-        try {
-            const response = await fetch(`${this.baseURL}/tenants/${this.tenantId}/crud/agent-relations`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({
-                    graphId: this.graphId,
-                    sourceAgentId: sourceAgent.getId(),
-                    targetAgentId: targetAgent.getId(),
-                    relationType,
-                }),
-            });
-            if (!response.ok) {
-                const errorText = await response.text().catch(() => 'Unknown error');
-                // Check if this is a duplicate relation (which is acceptable)
-                if (response.status === 422 && errorText.includes('already exists')) {
-                    logger.info({
-                        sourceAgentId: sourceAgent.getId(),
-                        targetAgentId: targetAgent.getId(),
-                        graphId: this.graphId,
-                        relationType,
-                    }, `${relationType} relation already exists, skipping creation`);
-                    return;
-                }
-                throw new Error(`Failed to create agent relation: ${response.status} - ${errorText}`);
-            }
-            logger.info({
-                sourceAgentId: sourceAgent.getId(),
-                targetAgentId: targetAgent.getId(),
-                graphId: this.graphId,
-                relationType,
-            }, `${relationType} relation created successfully`);
-        }
-        catch (error) {
-            logger.error({
-                sourceAgentId: sourceAgent.getId(),
-                targetAgentId: targetAgent.getId(),
-                graphId: this.graphId,
-                relationType,
-                error: error instanceof Error ? error.message : 'Unknown error',
-            }, `Failed to create ${relationType} relation`);
-            throw error;
-        }
-    }
-    // enableComponentMode removed – feature deprecated
-    async createExternalAgentRelation(sourceAgent, externalAgent, relationType) {
-        try {
-            const response = await fetch(`${this.baseURL}/tenants/${this.tenantId}/crud/agent-relations`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({
-                    graphId: this.graphId,
-                    sourceAgentId: sourceAgent.getId(),
-                    externalAgentId: externalAgent.getId(),
-                    relationType,
-                }),
-            });
-            if (!response.ok) {
-                const errorText = await response.text().catch(() => 'Unknown error');
-                // Check if this is a duplicate relation (which is acceptable)
-                if (response.status === 422 && errorText.includes('already exists')) {
-                    logger.info({
-                        sourceAgentId: sourceAgent.getId(),
-                        externalAgentId: externalAgent.getId(),
-                        graphId: this.graphId,
-                        relationType,
-                    }, `${relationType} relation already exists, skipping creation`);
-                    return;
-                }
-                throw new Error(`Failed to create external agent relation: ${response.status} - ${errorText}`);
-            }
-            logger.info({
-                sourceAgentId: sourceAgent.getId(),
-                externalAgentId: externalAgent.getId(),
-                graphId: this.graphId,
-                relationType,
-            }, `${relationType} relation created successfully`);
-        }
-        catch (error) {
-            logger.error({
-                sourceAgentId: sourceAgent.getId(),
-                externalAgentId: externalAgent.getId(),
-                graphId: this.graphId,
-                relationType,
-                error: error instanceof Error ? error.message : 'Unknown error',
-            }, `Failed to create ${relationType} relation`);
-            throw error;
-        }
-    }
-    /**
-     * Create external agents in the database
-     */
-    async createExternalAgents() {
-        const externalAgents = this.agents.filter((agent) => this.isExternalAgent(agent));
-        logger.info({
-            graphId: this.graphId,
-            externalAgentCount: externalAgents.length,
-        }, 'Creating external agents in database');
-        const initPromises = externalAgents.map(async (externalAgent) => {
-            try {
-                await externalAgent.init();
-                logger.debug({
-                    externalAgentId: externalAgent.getId(),
-                    graphId: this.graphId,
-                }, 'External agent created in database');
-            }
-            catch (error) {
-                logger.error({
-                    externalAgentId: externalAgent.getId(),
-                    graphId: this.graphId,
-                    error: error instanceof Error ? error.message : 'Unknown error',
-                }, 'Failed to create external agent in database');
-                throw error;
-            }
-        });
-        try {
-            await Promise.all(initPromises);
-            logger.info({
-                graphId: this.graphId,
-                externalAgentCount: externalAgents.length,
-            }, 'All external agents created successfully');
-        }
-        catch (error) {
-            logger.error({
-                graphId: this.graphId,
-                error: error instanceof Error ? error.message : 'Unknown error',
-            }, 'Failed to create some external agents');
-            throw error;
-        }
-    }
-}
-/**
- * Helper function to create graphs - OpenAI style
- */
-export function agentGraph(config) {
-    return new AgentGraph(config);
-}
-/**
- * Factory function to create graph from configuration file
- */
-export async function generateGraph(configPath) {
-    logger.info({ configPath }, 'Loading graph configuration');
-    try {
-        const config = await import(configPath);
-        const graphConfig = config.default || config;
-        const graph = agentGraph(graphConfig);
-        await graph.init();
-        logger.info({
-            configPath,
-            graphId: graph.getStats().graphId,
-            agentCount: graph.getStats().agentCount,
-        }, 'Graph generated successfully');
-        return graph;
-    }
-    catch (error) {
-        logger.error({
-            configPath,
-            error: error instanceof Error ? error.message : 'Unknown error',
-        }, 'Failed to generate graph from configuration');
-        throw error;
-    }
-}
-//# sourceMappingURL=graph.js.map