@inkeep/agents-run-api 0.1.3 → 0.1.6

package/dist/agents/generateTaskHandler.js

@@ -1,350 +0,0 @@
-import { getAgentById, getAgentGraph, getArtifactComponentsForAgent, getDataComponentsForAgent, getRelatedAgentsForGraph, getToolsForAgent, TaskState, } from '@inkeep/agents-core';
-import destr from 'destr'; // safe JSON.parse-if-JSON
-import { nanoid } from 'nanoid';
-import traverse from 'traverse'; // tiny object walker
-import dbClient from '../data/db/dbClient';
-import { getLogger } from '../logger';
-import { Agent } from './Agent';
-/** 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, credentialStoreRegistry) => {
-    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,
-            }, credentialStoreRegistry);
-            // 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

@@ -1,35 +0,0 @@
-import { type CredentialStoreRegistry } from '@inkeep/agents-core';
-import type { AgentConfig, DelegateRelation } from './Agent';
-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, credentialStoreRegistry, }: {
-    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;
-    credentialStoreRegistry?: CredentialStoreRegistry;
-}): 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

@@ -1 +0,0 @@
-{"version":3,"file":"relationTools.d.ts","sourceRoot":"","sources":["../../src/agents/relationTools.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,uBAAuB,EAK7B,MAAM,qBAAqB,CAAC;AAW7B,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AA2B7D,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,EACL,uBAAuB,GACxB,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;IACX,uBAAuB,CAAC,EAAE,uBAAuB,CAAC;CACnD;;;;;GAsNA"}

package/dist/agents/relationTools.js

@@ -1,246 +0,0 @@
-import { ContextResolver, CredentialStuffer, createMessage, getCredentialReference, getExternalAgent, } from '@inkeep/agents-core';
-import { trace } from '@opentelemetry/api';
-import { tool } from 'ai';
-import { nanoid } from 'nanoid';
-import z from 'zod';
-import { A2AClient } from '../a2a/client';
-import { saveA2AMessageResponse } from '../data/conversations';
-import dbClient from '../data/db/dbClient';
-import { getLogger } from '../logger';
-import { graphSessionManager } from '../utils/graph-session';
-import { toolSessionManager } from './ToolSessionManager';
-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, credentialStoreRegistry, }) {
-    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) &&
-                    credentialStoreRegistry) {
-                    const contextResolver = new ContextResolver(tenantId, projectId, dbClient, credentialStoreRegistry);
-                    const credentialStuffer = new CredentialStuffer(credentialStoreRegistry, 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

@@ -1,23 +0,0 @@
-import type { Artifact, ArtifactComponentApiInsert, DataComponentApiInsert } 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

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/agents/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,0BAA0B,EAC1B,sBAAsB,EACvB,MAAM,qBAAqB,CAAC;AAG7B,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

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