@inkeep/agents-run-api 0.1.0

package/dist/agents/generateTaskHandler.js

@@ -0,0 +1,350 @@
+import destr from 'destr'; // safe JSON.parse-if-JSON
+import { nanoid } from 'nanoid';
+import traverse from 'traverse'; // tiny object walker
+import { TaskState, getAgentGraph, getRelatedAgentsForGraph, getToolsForAgent, getAgentById, getArtifactComponentsForAgent, getDataComponentsForAgent, } from '@inkeep/agents-core';
+import { getLogger } from '../logger.js';
+import { Agent } from './Agent.js';
+import dbClient from '../data/db/dbClient.js';
+/** Turn any string value that is valid JSON into an object/array (in place). */
+export function parseEmbeddedJson(data) {
+    return traverse(data).map(function (x) {
+        if (typeof x === 'string') {
+            const v = destr(x); // returns original string if not JSON
+            if (v !== x && (Array.isArray(v) || (v && typeof v === 'object'))) {
+                this.update(v); // replace the string with the parsed value
+            }
+        }
+    });
+}
+const logger = getLogger('generateTaskHandler');
+export const createTaskHandler = (config) => {
+    return async (task) => {
+        try {
+            // Extract the user message from the task
+            const userMessage = task.input.parts
+                .filter((part) => part.text)
+                .map((part) => part.text)
+                .join(' ');
+            if (!userMessage.trim()) {
+                return {
+                    status: {
+                        state: TaskState.Failed,
+                        message: 'No text content found in task input',
+                    },
+                    artifacts: [],
+                };
+            }
+            const [{ internalRelations, externalRelations }, toolsForAgent, dataComponents, artifactComponents,] = await Promise.all([
+                getRelatedAgentsForGraph(dbClient)({
+                    scopes: {
+                        tenantId: config.tenantId,
+                        projectId: config.projectId,
+                    },
+                    graphId: config.graphId,
+                    agentId: config.agentId,
+                }),
+                getToolsForAgent(dbClient)({
+                    scopes: {
+                        tenantId: config.tenantId,
+                        projectId: config.projectId,
+                    },
+                    agentId: config.agentId,
+                }),
+                getDataComponentsForAgent(dbClient)({
+                    scopes: {
+                        tenantId: config.tenantId,
+                        projectId: config.projectId,
+                    },
+                    agentId: config.agentId,
+                }),
+                getArtifactComponentsForAgent(dbClient)({
+                    scopes: {
+                        tenantId: config.tenantId,
+                        projectId: config.projectId,
+                    },
+                    agentId: config.agentId,
+                }),
+            ]);
+            logger.info({ toolsForAgent, internalRelations, externalRelations }, 'agent stuff');
+            // Check if this is an internal agent (has prompt)
+            const agentPrompt = 'prompt' in config.agentSchema ? config.agentSchema.prompt : '';
+            const models = 'models' in config.agentSchema ? config.agentSchema.models : undefined;
+            const stopWhen = 'stopWhen' in config.agentSchema ? config.agentSchema.stopWhen : undefined;
+            const agent = new Agent({
+                id: config.agentId,
+                tenantId: config.tenantId,
+                projectId: config.projectId,
+                graphId: config.graphId,
+                baseUrl: config.baseUrl,
+                apiKey: config.apiKey,
+                name: config.name,
+                description: config.description || '',
+                agentPrompt,
+                models: models || undefined,
+                stopWhen: stopWhen || undefined,
+                agentRelations: internalRelations.map((relation) => ({
+                    id: relation.id,
+                    tenantId: config.tenantId,
+                    projectId: config.projectId,
+                    graphId: config.graphId,
+                    baseUrl: config.baseUrl,
+                    apiKey: config.apiKey,
+                    name: relation.name,
+                    description: relation.description,
+                    agentPrompt: '',
+                    delegateRelations: [],
+                    agentRelations: [],
+                    transferRelations: [],
+                })),
+                transferRelations: internalRelations
+                    .filter((relation) => relation.relationType === 'transfer')
+                    .map((relation) => ({
+                    baseUrl: config.baseUrl,
+                    apiKey: config.apiKey,
+                    id: relation.id,
+                    tenantId: config.tenantId,
+                    projectId: config.projectId,
+                    graphId: config.graphId,
+                    name: relation.name,
+                    description: relation.description,
+                    agentPrompt: '',
+                    delegateRelations: [],
+                    agentRelations: [],
+                    transferRelations: [],
+                })),
+                delegateRelations: [
+                    // Internal delegate relations
+                    ...internalRelations
+                        .filter((relation) => relation.relationType === 'delegate')
+                        .map((relation) => ({
+                        type: 'internal',
+                        config: {
+                            id: relation.id,
+                            tenantId: config.tenantId,
+                            projectId: config.projectId,
+                            graphId: config.graphId,
+                            baseUrl: config.baseUrl,
+                            apiKey: config.apiKey,
+                            name: relation.name,
+                            description: relation.description,
+                            agentPrompt: '',
+                            delegateRelations: [],
+                            agentRelations: [],
+                            transferRelations: [],
+                        },
+                    })),
+                    // External delegate relations
+                    ...externalRelations.map((relation) => ({
+                        type: 'external',
+                        config: {
+                            id: relation.externalAgent.id,
+                            name: relation.externalAgent.name,
+                            description: relation.externalAgent.description || '',
+                            baseUrl: relation.externalAgent.baseUrl,
+                            relationType: relation.relationType || undefined,
+                        },
+                    })),
+                ],
+                tools: toolsForAgent.data.map((item) => ({
+                    ...item.tool,
+                    capabilities: item.tool.capabilities || undefined,
+                    lastHealthCheck: item.tool.lastHealthCheck
+                        ? new Date(item.tool.lastHealthCheck)
+                        : undefined,
+                    lastToolsSync: item.tool.lastToolsSync
+                        ? new Date(item.tool.lastToolsSync)
+                        : undefined,
+                    createdAt: new Date(item.tool.createdAt),
+                    updatedAt: new Date(item.tool.updatedAt),
+                })) ?? [],
+                functionTools: [], // All tools are now handled via MCP servers
+                dataComponents: dataComponents,
+                artifactComponents: artifactComponents,
+                contextConfigId: config.contextConfigId || undefined,
+                conversationHistoryConfig: config.conversationHistoryConfig,
+            });
+            // More robust contextId resolution for delegation scenarios
+            let contextId = task.context?.conversationId;
+            // If contextId is not set in task.context, try to extract it from the task.id
+            // Many tasks are created with IDs like "task_math-demo-123456-chatcmpl-789"
+            if (!contextId || contextId === 'default' || contextId === '') {
+                const taskIdMatch = task.id.match(/^task_([^-]+-[^-]+-\d+)-/);
+                if (taskIdMatch) {
+                    contextId = taskIdMatch[1];
+                    logger.info({
+                        taskId: task.id,
+                        extractedContextId: contextId,
+                        agentId: config.agentId,
+                    }, 'Extracted contextId from task ID for delegation');
+                }
+                else {
+                    contextId = 'default';
+                }
+            }
+            // Extract streaming context from task metadata and get streamHelper from registry
+            const streamRequestId = task.context?.metadata?.stream_request_id || task.context?.metadata?.streamRequestId;
+            // Check if this is a delegation - delegated agents should not stream to user
+            const isDelegation = task.context?.metadata?.isDelegation === true;
+            agent.setDelegationStatus(isDelegation);
+            if (isDelegation) {
+                logger.info({ agentId: config.agentId, taskId: task.id }, 'Delegated agent - streaming disabled');
+            }
+            const response = await agent.generate(userMessage, {
+                contextId,
+                metadata: {
+                    conversationId: contextId,
+                    taskId: task.id,
+                    threadId: contextId, // using conversationId as threadId for now
+                    streamRequestId: streamRequestId,
+                },
+            });
+            // Process steps to extract tool calls and results from content arrays
+            const stepContents = response.steps && Array.isArray(response.steps)
+                ? response.steps.flatMap((step) => {
+                    return step.content && Array.isArray(step.content) ? step.content : [];
+                })
+                : [];
+            const allToolCalls = stepContents.filter((content) => content.type === 'tool-call');
+            const allToolResults = stepContents.filter((content) => content.type === 'tool-result');
+            const allThoughts = stepContents.filter((content) => content.type === 'text');
+            if (allToolCalls.length > 0) {
+                for (const toolCall of allToolCalls) {
+                    // Check for transfer tool calls (we support multiple patterns)
+                    if (toolCall.toolName.includes('transfer') ||
+                        toolCall.toolName.includes('transferToRefundAgent')) {
+                        // Look for the tool result
+                        const toolResult = allToolResults.find((result) => result.toolCallId === toolCall.toolCallId);
+                        // Validate transfer result with proper type checking
+                        const isValidTransferResult = (output) => {
+                            return (typeof output === 'object' &&
+                                output !== null &&
+                                'type' in output &&
+                                'target' in output &&
+                                output.type === 'transfer' &&
+                                typeof output.target === 'string' &&
+                                (output.reason === undefined || typeof output.reason === 'string'));
+                        };
+                        //In the agent.generate response, response.text is not always populated. In that case, use allThoughts to get the last text part found in the steps array.
+                        const responseText = response.text ||
+                            (response.object ? JSON.stringify(response.object) : '');
+                        const transferReason = responseText ||
+                            allThoughts[allThoughts.length - 1]?.text ||
+                            'Agent requested transfer. No reason provided.';
+                        if (toolResult?.output && isValidTransferResult(toolResult.output)) {
+                            const transferResult = toolResult.output;
+                            // Return transfer indication in A2A format
+                            return {
+                                status: {
+                                    state: TaskState.Completed,
+                                    message: `Transfer requested to ${transferResult.target}`,
+                                },
+                                artifacts: [
+                                    {
+                                        artifactId: nanoid(),
+                                        parts: [
+                                            {
+                                                kind: 'data',
+                                                data: {
+                                                    type: 'transfer',
+                                                    target: transferResult.target,
+                                                    task_id: task.id,
+                                                    reason: transferReason,
+                                                    original_message: userMessage,
+                                                },
+                                            },
+                                        ],
+                                    },
+                                ],
+                            };
+                        }
+                    }
+                }
+            }
+            // Use formatted content parts if available, otherwise fall back to response.text
+            const parts = (response.formattedContent?.parts || []).map((part) => ({
+                kind: part.kind,
+                ...(part.kind === 'text' && { text: part.text }),
+                ...(part.kind === 'data' && { data: part.data }),
+            }));
+            return {
+                status: { state: TaskState.Completed },
+                artifacts: [
+                    {
+                        artifactId: nanoid(),
+                        parts,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            console.error('Task handler error:', error);
+            return {
+                status: {
+                    state: TaskState.Failed,
+                    message: error instanceof Error ? error.message : 'Unknown error occurred',
+                },
+                artifacts: [],
+            };
+        }
+    };
+};
+/**
+ * Serializes a TaskHandlerConfig to JSON
+ */
+export const serializeTaskHandlerConfig = (config) => {
+    return JSON.stringify(config, null, 2);
+};
+/**
+ * Deserializes a TaskHandlerConfig from JSON
+ */
+export const deserializeTaskHandlerConfig = (configJson) => {
+    return JSON.parse(configJson);
+};
+/**
+ * Creates a task handler configuration from agent data
+ */
+export const createTaskHandlerConfig = async (params) => {
+    const agent = await getAgentById(dbClient)({
+        scopes: {
+            tenantId: params.tenantId,
+            projectId: params.projectId,
+        },
+        agentId: params.agentId,
+    });
+    const agentGraph = await getAgentGraph(dbClient)({
+        scopes: {
+            tenantId: params.tenantId,
+            projectId: params.projectId,
+        },
+        graphId: params.graphId,
+    });
+    if (!agent) {
+        throw new Error(`Agent not found: ${params.agentId}`);
+    }
+    // Inherit graph models if agent doesn't have one
+    const effectiveModels = agent.models || agentGraph?.models || undefined;
+    const effectiveConversationHistoryConfig = agent.conversationHistoryConfig || { mode: 'full' };
+    return {
+        tenantId: params.tenantId,
+        projectId: params.projectId,
+        graphId: params.graphId,
+        agentId: params.agentId,
+        agentSchema: {
+            id: agent.id,
+            name: agent.name,
+            description: agent.description,
+            prompt: agent.prompt,
+            models: effectiveModels || null,
+            conversationHistoryConfig: effectiveConversationHistoryConfig || null,
+            stopWhen: agent.stopWhen || null,
+            createdAt: agent.createdAt,
+            updatedAt: agent.updatedAt,
+        },
+        baseUrl: params.baseUrl,
+        apiKey: params.apiKey,
+        name: agent.name,
+        description: agent.description,
+        conversationHistoryConfig: effectiveConversationHistoryConfig,
+        contextConfigId: agentGraph?.contextConfigId || undefined,
+    };
+};

package/dist/agents/relationTools.d.ts

@@ -0,0 +1,33 @@
+import type { AgentConfig, DelegateRelation } from './Agent.js';
+export declare const createTransferToAgentTool: ({ transferConfig, callingAgentId, agent, streamRequestId, }: {
+    transferConfig: AgentConfig;
+    callingAgentId: string;
+    agent: any;
+    streamRequestId?: string;
+}) => import("ai").Tool<Record<string, never>, {
+    type: string;
+    target: string;
+    fromAgentId: string;
+}>;
+export declare function createDelegateToAgentTool({ delegateConfig, callingAgentId, tenantId, projectId, graphId, contextId, metadata, sessionId, agent, }: {
+    delegateConfig: DelegateRelation;
+    callingAgentId: string;
+    tenantId: string;
+    projectId: string;
+    graphId: string;
+    contextId: string;
+    metadata: {
+        conversationId: string;
+        threadId: string;
+        streamRequestId?: string;
+        streamBaseUrl?: string;
+    };
+    sessionId?: string;
+    agent: any;
+}): import("ai").Tool<{
+    message: string;
+}, {
+    toolCallId: any;
+    result: import("@inkeep/agents-core").Message | import("@inkeep/agents-core").Task;
+}>;
+//# sourceMappingURL=relationTools.d.ts.map

package/dist/agents/relationTools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relationTools.d.ts","sourceRoot":"","sources":["../../src/agents/relationTools.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AA2BhE,eAAO,MAAM,yBAAyB,GAAI,6DAKvC;IACD,cAAc,EAAE,WAAW,CAAC;IAC5B,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,GAAG,CAAC;IACX,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;;;;EAsCA,CAAC;AAEF,wBAAgB,yBAAyB,CAAC,EACxC,cAAc,EACd,cAAc,EACd,QAAQ,EACR,SAAS,EACT,OAAO,EACP,SAAS,EACT,QAAQ,EACR,SAAS,EACT,KAAK,GACN,EAAE;IACD,cAAc,EAAE,gBAAgB,CAAC;IACjC,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE;QACR,cAAc,EAAE,MAAM,CAAC;QACvB,QAAQ,EAAE,MAAM,CAAC;QACjB,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,aAAa,CAAC,EAAE,MAAM,CAAC;KACxB,CAAC;IACF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,GAAG,CAAC;CACZ;;;;;GAkNA"}

package/dist/agents/relationTools.js

@@ -0,0 +1,245 @@
+import { trace } from '@opentelemetry/api';
+import { tool } from 'ai';
+import { nanoid } from 'nanoid';
+import z from 'zod';
+import { A2AClient } from '../a2a/client.js';
+import { createMessage, getCredentialReference, getExternalAgent, CredentialStuffer, ContextResolver, } from '@inkeep/agents-core';
+import { saveA2AMessageResponse } from '../data/conversations.js';
+import dbClient from '../data/db/dbClient.js';
+import { executionServer } from '../index.js';
+import { getLogger } from '../logger.js';
+import { graphSessionManager } from '../utils/graph-session.js';
+import { toolSessionManager } from './ToolSessionManager.js';
+const logger = getLogger('relationships Tools');
+const generateTransferToolDescription = (config) => {
+    return `Hand off the conversation to agent ${config.id}.
+
+Agent Information:
+- ID: ${config.id}
+- Name: ${config.name ?? 'No name provided'}
+- Description: ${config.description ?? 'No description provided'}
+
+Hand off the conversation to agent ${config.id} when the user's request would be better handled by this specialized agent.`;
+};
+const generateDelegateToolDescription = (config) => {
+    return `Delegate a specific task to another agent.
+
+Agent Information:
+- ID: ${config.id}
+- Name: ${config.name}
+- Description: ${config.description || 'No description provided'}
+
+Delegate a specific task to agent ${config.id} when it seems like the agent can do relevant work.`;
+};
+export const createTransferToAgentTool = ({ transferConfig, callingAgentId, agent, streamRequestId, }) => {
+    return tool({
+        description: generateTransferToolDescription(transferConfig),
+        inputSchema: z.object({}),
+        execute: async () => {
+            // Add span attributes to indicate transfer source and target
+            const activeSpan = trace.getActiveSpan();
+            if (activeSpan) {
+                activeSpan.setAttributes({
+                    'transfer.from_agent_id': callingAgentId,
+                    'transfer.to_agent_id': transferConfig.id ?? 'unknown',
+                });
+            }
+            logger.info({
+                transferTo: transferConfig.id ?? 'unknown',
+                fromAgent: callingAgentId,
+            }, 'invoked transferToAgentTool');
+            // Record transfer event in GraphSession
+            if (streamRequestId) {
+                graphSessionManager.recordEvent(streamRequestId, 'transfer', callingAgentId, {
+                    fromAgent: callingAgentId,
+                    targetAgent: transferConfig.id ?? 'unknown',
+                    reason: `Transfer to ${transferConfig.name || transferConfig.id}`,
+                });
+            }
+            return {
+                type: 'transfer',
+                target: transferConfig.id ?? 'unknown',
+                fromAgentId: callingAgentId, // Include the calling agent ID for tracking
+            };
+        },
+    });
+};
+export function createDelegateToAgentTool({ delegateConfig, callingAgentId, tenantId, projectId, graphId, contextId, metadata, sessionId, agent, }) {
+    return tool({
+        description: generateDelegateToolDescription(delegateConfig.config),
+        inputSchema: z.object({ message: z.string() }),
+        execute: async (input, context) => {
+            // Generate unique delegation ID for tracking
+            const delegationId = `del_${nanoid()}`;
+            // Add span attributes to indicate delegation source and target
+            const activeSpan = trace.getActiveSpan();
+            if (activeSpan) {
+                activeSpan.setAttributes({
+                    'delegation.from_agent_id': callingAgentId,
+                    'delegation.to_agent_id': delegateConfig.config.id ?? 'unknown',
+                    'delegation.id': delegationId,
+                });
+            }
+            // Record delegation sent event in GraphSession
+            if (metadata.streamRequestId) {
+                graphSessionManager.recordEvent(metadata.streamRequestId, 'delegation_sent', callingAgentId, {
+                    delegationId,
+                    fromAgent: callingAgentId,
+                    targetAgent: delegateConfig.config.id,
+                    taskDescription: input.message,
+                });
+            }
+            const isInternal = delegateConfig.type === 'internal';
+            // Get the base URL for the agent
+            let agentBaseUrl;
+            let resolvedHeaders = {};
+            if (!isInternal) {
+                agentBaseUrl = delegateConfig.config.baseUrl;
+                // For external agents, fetch configuration
+                const externalAgent = await getExternalAgent(dbClient)({
+                    scopes: {
+                        tenantId,
+                        projectId,
+                    },
+                    agentId: delegateConfig.config.id,
+                });
+                // If the external agent has a credential reference ID or headers, resolve them
+                if (externalAgent && (externalAgent.credentialReferenceId || externalAgent.headers)) {
+                    const contextResolver = new ContextResolver(tenantId, projectId, dbClient, executionServer);
+                    const credentialStuffer = new CredentialStuffer(executionServer, contextResolver);
+                    const credentialContext = {
+                        tenantId,
+                        projectId,
+                        conversationId: metadata.conversationId,
+                        contextConfigId: contextId,
+                        metadata: metadata,
+                    };
+                    let storeReference;
+                    if (externalAgent.credentialReferenceId) {
+                        // Get credential store configuration
+                        const credentialReference = await getCredentialReference(dbClient)({
+                            scopes: {
+                                tenantId,
+                                projectId,
+                            },
+                            id: externalAgent.credentialReferenceId,
+                        });
+                        if (credentialReference) {
+                            storeReference = {
+                                credentialStoreId: credentialReference.credentialStoreId,
+                                retrievalParams: credentialReference.retrievalParams || {},
+                            };
+                        }
+                    }
+                    // Resolve credentials using CredentialStuffer
+                    resolvedHeaders = await credentialStuffer.getCredentialHeaders({
+                        context: credentialContext,
+                        storeReference,
+                        headers: externalAgent.headers || undefined,
+                    });
+                }
+            }
+            else {
+                resolvedHeaders = {
+                    Authorization: `Bearer ${delegateConfig.config.apiKey}`,
+                    'x-inkeep-tenant-id': tenantId,
+                    'x-inkeep-project-id': projectId,
+                    'x-inkeep-graph-id': graphId,
+                    'x-inkeep-agent-id': delegateConfig.config.id,
+                };
+            }
+            // Configure retry behavior for A2A client with custom settings and resolved headers
+            const a2aClient = new A2AClient(delegateConfig.config.baseUrl, {
+                headers: resolvedHeaders,
+                retryConfig: {
+                    strategy: 'backoff',
+                    retryConnectionErrors: true,
+                    statusCodes: ['429', '500', '502', '503', '504'],
+                    backoff: {
+                        initialInterval: 100,
+                        maxInterval: 10000,
+                        exponent: 2,
+                        maxElapsedTime: 20000, // 1 minute max retry time
+                    },
+                },
+            });
+            // Create the message to send to the agent
+            // Keep streamRequestId for GraphSession access, add isDelegation flag to prevent streaming
+            const messageToSend = {
+                role: 'agent',
+                parts: [{ text: input.message, kind: 'text' }],
+                messageId: nanoid(),
+                kind: 'message',
+                contextId,
+                metadata: {
+                    ...metadata, // Keep all metadata including streamRequestId
+                    isDelegation: true, // Flag to prevent streaming in delegated agents
+                    delegationId, // Include delegation ID for tracking
+                    ...(isInternal
+                        ? { fromAgentId: callingAgentId }
+                        : { fromExternalAgentId: callingAgentId }),
+                },
+            };
+            logger.info({ messageToSend }, 'messageToSend');
+            // Record the outgoing message to the agent
+            await createMessage(dbClient)({
+                id: nanoid(),
+                tenantId: tenantId,
+                projectId: projectId,
+                conversationId: contextId,
+                role: 'agent',
+                content: {
+                    text: input.message,
+                },
+                visibility: isInternal ? 'internal' : 'external',
+                messageType: 'a2a-request',
+                fromAgentId: callingAgentId,
+                ...(isInternal
+                    ? { toAgentId: delegateConfig.config.id }
+                    : { toExternalAgentId: delegateConfig.config.id }),
+            });
+            const response = await a2aClient.sendMessage({
+                message: messageToSend,
+            });
+            if (response.error) {
+                throw new Error(response.error.message);
+            }
+            // Save the response using the reusable function
+            await saveA2AMessageResponse(response, {
+                tenantId,
+                projectId,
+                conversationId: contextId,
+                messageType: 'a2a-response',
+                visibility: isInternal ? 'internal' : 'external',
+                toAgentId: callingAgentId,
+                ...(isInternal
+                    ? { fromAgentId: delegateConfig.config.id }
+                    : { fromExternalAgentId: delegateConfig.config.id }),
+            });
+            // Record the delegation result as a tool result for the parent agent
+            if (sessionId && context?.toolCallId) {
+                const toolResult = {
+                    toolCallId: context.toolCallId,
+                    toolName: `delegate_to_${delegateConfig.config.id}`,
+                    args: input,
+                    result: response.result,
+                    timestamp: Date.now(),
+                };
+                toolSessionManager.recordToolResult(sessionId, toolResult);
+            }
+            // Record delegation returned event in GraphSession
+            if (metadata.streamRequestId) {
+                graphSessionManager.recordEvent(metadata.streamRequestId, 'delegation_returned', callingAgentId, {
+                    delegationId,
+                    fromAgent: delegateConfig.config.id,
+                    targetAgent: callingAgentId,
+                    result: response.result,
+                });
+            }
+            return {
+                toolCallId: context?.toolCallId,
+                result: response.result,
+            };
+        },
+    });
+}

package/dist/agents/types.d.ts

@@ -0,0 +1,23 @@
+import type { DataComponentApiInsert, ArtifactComponentApiInsert, Artifact } from '@inkeep/agents-core';
+export interface VersionConfig<TConfig> {
+    templateFiles: string[];
+    assemble(templates: Map<string, string>, config: TConfig): string;
+}
+export interface SystemPromptV1 {
+    corePrompt: string;
+    graphPrompt?: string;
+    artifacts: Artifact[];
+    tools: ToolData[];
+    dataComponents: DataComponentApiInsert[];
+    artifactComponents?: ArtifactComponentApiInsert[];
+    isThinkingPreparation?: boolean;
+    hasTransferRelations?: boolean;
+    hasDelegateRelations?: boolean;
+}
+export interface ToolData {
+    name: string;
+    description?: string;
+    inputSchema?: Record<string, unknown>;
+    usageGuidelines?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/agents/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/agents/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,0BAA0B,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAGxG,MAAM,WAAW,aAAa,CAAC,OAAO;IACpC,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,OAAO,GAAG,MAAM,CAAC;CACnE;AAED,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB,cAAc,EAAE,sBAAsB,EAAE,CAAC;IACzC,kBAAkB,CAAC,EAAE,0BAA0B,EAAE,CAAC;IAClD,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACtC,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B"}

package/dist/agents/types.js

@@ -0,0 +1 @@
+export {};