@inkeep/agents-run-api 0.0.0-dev-20250910232631

package/dist/routes/chat.js

@@ -0,0 +1,307 @@
+import { createRoute, OpenAPIHono } from '@hono/zod-openapi';
+import { contextValidationMiddleware, createMessage, createOrGetConversation, getActiveAgentForConversation, getAgentById, getAgentGraphWithDefaultAgent, getFullGraph, getRequestExecutionContext, handleContextResolution, setActiveAgentForConversation, } from '@inkeep/agents-core';
+// import { Hono } from 'hono';
+import { trace } from '@opentelemetry/api';
+import { streamSSE } from 'hono/streaming';
+import { nanoid } from 'nanoid';
+import { z } from 'zod';
+import dbClient from '../data/db/dbClient';
+import { ExecutionHandler } from '../handlers/executionHandler';
+import { getLogger } from '../logger';
+import { createSSEStreamHelper } from '../utils/stream-helpers';
+const app = new OpenAPIHono();
+const logger = getLogger('completionsHandler');
+// Define the OpenAPI route schema
+const chatCompletionsRoute = createRoute({
+    method: 'post',
+    path: '/completions',
+    tags: ['chat'],
+    summary: 'Create chat completion',
+    description: 'Creates a new chat completion with streaming SSE response using the configured agent graph',
+    security: [{ bearerAuth: [] }],
+    request: {
+        body: {
+            content: {
+                'application/json': {
+                    schema: z.object({
+                        model: z.string().describe('The model to use for the completion'),
+                        messages: z
+                            .array(z.object({
+                            role: z
+                                .enum(['system', 'user', 'assistant', 'function', 'tool'])
+                                .describe('The role of the message'),
+                            content: z
+                                .union([
+                                z.string(),
+                                z.array(z.strictObject({
+                                    type: z.string(),
+                                    text: z.string().optional(),
+                                })),
+                            ])
+                                .describe('The message content'),
+                            name: z.string().optional().describe('The name of the message sender'),
+                        }))
+                            .describe('The conversation messages'),
+                        temperature: z.number().optional().describe('Controls randomness (0-1)'),
+                        top_p: z.number().optional().describe('Controls nucleus sampling'),
+                        n: z.number().optional().describe('Number of completions to generate'),
+                        stream: z.boolean().optional().describe('Whether to stream the response'),
+                        max_tokens: z.number().optional().describe('Maximum tokens to generate'),
+                        presence_penalty: z.number().optional().describe('Presence penalty (-2 to 2)'),
+                        frequency_penalty: z.number().optional().describe('Frequency penalty (-2 to 2)'),
+                        logit_bias: z.record(z.string(), z.number()).optional().describe('Token logit bias'),
+                        user: z.string().optional().describe('User identifier'),
+                        conversationId: z.string().optional().describe('Conversation ID for multi-turn chat'),
+                        tools: z.array(z.string()).optional().describe('Available tools'),
+                        runConfig: z.record(z.string(), z.unknown()).optional().describe('Run configuration'),
+                        requestContext: z
+                            .record(z.string(), z.unknown())
+                            .optional()
+                            .describe('Context data for template processing (validated against context config schema)'),
+                    }),
+                },
+            },
+        },
+    },
+    responses: {
+        200: {
+            description: 'Streaming chat completion response in Server-Sent Events format',
+            headers: z.object({
+                'Content-Type': z.string().default('text/event-stream'),
+                'Cache-Control': z.string().default('no-cache'),
+                Connection: z.string().default('keep-alive'),
+            }),
+            content: {
+                'text/event-stream': {
+                    schema: z.string().describe('Server-Sent Events stream with chat completion chunks'),
+                },
+            },
+        },
+        400: {
+            description: 'Invalid request context or parameters',
+            content: {
+                'application/json': {
+                    schema: z.object({
+                        error: z.string(),
+                        details: z
+                            .array(z.object({
+                            field: z.string(),
+                            message: z.string(),
+                            value: z.unknown().optional(),
+                        }))
+                            .optional(),
+                    }),
+                },
+            },
+        },
+        404: {
+            description: 'Agent graph or agent not found',
+            content: {
+                'application/json': {
+                    schema: z.object({
+                        error: z.string(),
+                    }),
+                },
+            },
+        },
+        500: {
+            description: 'Internal server error',
+            content: {
+                'application/json': {
+                    schema: z.object({
+                        error: z.string(),
+                        message: z.string(),
+                    }),
+                },
+            },
+        },
+    },
+});
+// Apply context validation middleware
+app.use('/completions', contextValidationMiddleware(dbClient));
+app.openapi(chatCompletionsRoute, async (c) => {
+    getLogger('chat').info({
+        path: c.req.path,
+        method: c.req.method,
+        params: c.req.param(),
+    }, 'Chat route accessed');
+    const otelHeaders = {
+        traceparent: c.req.header('traceparent'),
+        tracestate: c.req.header('tracestate'),
+        baggage: c.req.header('baggage'),
+    };
+    logger.info({
+        otelHeaders,
+        path: c.req.path,
+        method: c.req.method,
+    }, 'OpenTelemetry headers: chat');
+    try {
+        // Get execution context from API key authentication
+        const executionContext = getRequestExecutionContext(c);
+        const { tenantId, projectId, graphId } = executionContext;
+        getLogger('chat').debug({
+            tenantId,
+            graphId,
+        }, 'Extracted chat parameters from API key context');
+        // Get conversationId from request body or generate new one
+        const body = c.req.valid('json');
+        const conversationId = body.conversationId || nanoid();
+        // Get the graph from the full graph system first, fall back to legacy system
+        const fullGraph = await getFullGraph(dbClient)({
+            scopes: { tenantId, projectId },
+            graphId,
+        });
+        let agentGraph;
+        let defaultAgentId;
+        if (fullGraph) {
+            // Use full graph system
+            agentGraph = {
+                id: fullGraph.id,
+                name: fullGraph.name,
+                tenantId,
+                projectId,
+                defaultAgentId: fullGraph.defaultAgentId,
+            };
+            const agentKeys = Object.keys(fullGraph.agents || {});
+            const firstAgentId = agentKeys.length > 0 ? agentKeys[0] : '';
+            defaultAgentId = fullGraph.defaultAgentId || firstAgentId; // Use first agent if no defaultAgentId
+        }
+        else {
+            // Fall back to legacy system
+            agentGraph = await getAgentGraphWithDefaultAgent(dbClient)({
+                scopes: { tenantId, projectId },
+                graphId,
+            });
+            if (!agentGraph) {
+                return c.json({ error: 'Agent graph not found' }, 404);
+            }
+            defaultAgentId = agentGraph.defaultAgentId || '';
+        }
+        if (!defaultAgentId) {
+            return c.json({ error: 'No default agent found in graph' }, 404);
+        }
+        // Get or create conversation with the default agent
+        await createOrGetConversation(dbClient)({
+            tenantId,
+            projectId,
+            id: conversationId,
+            activeAgentId: defaultAgentId,
+        });
+        const activeAgent = await getActiveAgentForConversation(dbClient)({
+            scopes: { tenantId, projectId },
+            conversationId,
+        });
+        if (!activeAgent) {
+            // Use the default agent from the graph instead of headAgentId
+            setActiveAgentForConversation(dbClient)({
+                scopes: { tenantId, projectId },
+                conversationId,
+                agentId: defaultAgentId,
+            });
+        }
+        const agentId = activeAgent?.activeAgentId || defaultAgentId;
+        const agentInfo = await getAgentById(dbClient)({
+            scopes: { tenantId, projectId },
+            agentId: agentId,
+        });
+        if (!agentInfo) {
+            return c.json({ error: 'Agent not found' }, 404);
+        }
+        // Get validated context from middleware (falls back to body.context if no validation)
+        const validatedContext = c.get('validatedContext') || body.requestContext || {};
+        const credentialStores = c.get('credentialStores');
+        // Context resolution with intelligent conversation state detection
+        await handleContextResolution(tenantId, projectId, conversationId, graphId, validatedContext, dbClient, credentialStores);
+        logger.info({
+            tenantId,
+            graphId,
+            conversationId,
+            defaultAgentId,
+            activeAgentId: activeAgent?.activeAgentId || 'none',
+            hasContextConfig: !!agentGraph.contextConfigId,
+            hasRequestContext: !!body.requestContext,
+            hasValidatedContext: !!validatedContext,
+            validatedContextKeys: Object.keys(validatedContext),
+        }, 'parameters');
+        const requestId = `chatcmpl-${Date.now()}`;
+        const timestamp = Math.floor(Date.now() / 1000);
+        // Extract user message for context
+        const lastUserMessage = body.messages
+            .filter((msg) => msg.role === 'user')
+            .slice(-1)[0];
+        const userMessage = lastUserMessage ? getMessageText(lastUserMessage.content) : '';
+        const messageSpan = trace.getActiveSpan();
+        if (messageSpan) {
+            messageSpan.setAttributes({
+                'message.content': userMessage,
+                'message.timestamp': Date.now(),
+            });
+        }
+        // Store the user message in the database
+        await createMessage(dbClient)({
+            id: nanoid(),
+            tenantId,
+            projectId,
+            conversationId,
+            role: 'user',
+            content: {
+                text: userMessage,
+            },
+            visibility: 'user-facing',
+            messageType: 'chat',
+        });
+        if (messageSpan) {
+            messageSpan.addEvent('user.message.stored', {
+                'message.id': conversationId,
+                'database.operation': 'insert',
+            });
+        }
+        // Use Hono's streamSSE helper for proper SSE formatting
+        return streamSSE(c, async (stream) => {
+            // Create SSE stream helper
+            const sseHelper = createSSEStreamHelper(stream, requestId, timestamp);
+            // Start with the role
+            await sseHelper.writeRole();
+            logger.info({ agentId }, 'Starting execution');
+            // Use the execution handler
+            const executionHandler = new ExecutionHandler();
+            const result = await executionHandler.execute({
+                executionContext,
+                conversationId,
+                userMessage,
+                initialAgentId: agentId,
+                requestId,
+                sseHelper,
+            });
+            logger.info({ result }, `Execution completed: ${result.success ? 'success' : 'failed'} after ${result.iterations} iterations`);
+            if (!result.success) {
+                // If execution failed and no error was already streamed, send a default error
+                await sseHelper.writeError('Sorry, I was unable to process your request at this time. Please try again.');
+            }
+            // Complete the stream
+            await sseHelper.complete();
+        });
+    }
+    catch (error) {
+        console.error('❌ Error in chat completions endpoint:', {
+            error: error instanceof Error ? error.message : error,
+            stack: error instanceof Error ? error.stack : undefined,
+        });
+        return c.json({
+            error: 'Failed to process chat completion',
+            message: error instanceof Error ? error.message : 'Unknown error',
+        }, 500);
+    }
+});
+// Helper function to extract text from content
+const getMessageText = (content) => {
+    if (typeof content === 'string') {
+        return content;
+    }
+    // For content arrays, extract text from all text items
+    return content
+        .filter((item) => item.type === 'text' && item.text)
+        .map((item) => item.text)
+        .join(' ');
+};
+export default app;

package/dist/routes/chatDataStream.d.ts

@@ -0,0 +1,10 @@
+import { OpenAPIHono } from '@hono/zod-openapi';
+import { type CredentialStoreRegistry } from '@inkeep/agents-core';
+type AppVariables = {
+    credentialStores: CredentialStoreRegistry;
+};
+declare const app: OpenAPIHono<{
+    Variables: AppVariables;
+}, {}, "/">;
+export default app;
+//# sourceMappingURL=chatDataStream.d.ts.map

package/dist/routes/chatDataStream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chatDataStream.d.ts","sourceRoot":"","sources":["../../src/routes/chatDataStream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,WAAW,EAAK,MAAM,mBAAmB,CAAC;AAChE,OAAO,EACL,KAAK,uBAAuB,EAU7B,MAAM,qBAAqB,CAAC;AAU7B,KAAK,YAAY,GAAG;IAClB,gBAAgB,EAAE,uBAAuB,CAAC;CAC3C,CAAC;AAEF,QAAA,MAAM,GAAG;eAAgC,YAAY;WAAK,CAAC;AA4M3D,eAAe,GAAG,CAAC"}

package/dist/routes/chatDataStream.js

@@ -0,0 +1,185 @@
+import { createRoute, OpenAPIHono, z } from '@hono/zod-openapi';
+import { commonGetErrorResponses, contextValidationMiddleware, createMessage, getActiveAgentForConversation, getAgentById, getAgentGraphWithDefaultAgent, getRequestExecutionContext, handleContextResolution, setActiveAgentForConversation, } from '@inkeep/agents-core';
+import { trace } from '@opentelemetry/api';
+import { createUIMessageStream, JsonToSseTransformStream } from 'ai';
+import { stream } from 'hono/streaming';
+import { nanoid } from 'nanoid';
+import dbClient from '../data/db/dbClient';
+import { ExecutionHandler } from '../handlers/executionHandler';
+import { getLogger } from '../logger';
+import { createVercelStreamHelper } from '../utils/stream-helpers';
+const app = new OpenAPIHono();
+const logger = getLogger('chatDataStream');
+const chatDataStreamRoute = createRoute({
+    method: 'post',
+    path: '/chat',
+    tags: ['chat'],
+    summary: 'Chat (Vercel Streaming Protocol)',
+    description: 'Chat completion endpoint streaming with Vercel data stream protocol.',
+    security: [{ bearerAuth: [] }],
+    request: {
+        body: {
+            content: {
+                'application/json': {
+                    schema: z.object({
+                        model: z.string().optional(),
+                        messages: z.array(z.object({
+                            role: z.enum(['system', 'user', 'assistant', 'function', 'tool']),
+                            content: z.any(),
+                            parts: z
+                                .array(z.object({
+                                type: z.union([
+                                    z.enum(['text', 'image', 'audio', 'video', 'file']),
+                                    z.string().regex(/^data-/, 'Type must start with "data-"'),
+                                ]),
+                                text: z.string().optional(),
+                            }))
+                                .optional(),
+                        })),
+                        id: z.string().optional(),
+                        conversationId: z.string().optional(),
+                        requestContext: z
+                            .record(z.string(), z.unknown())
+                            .optional()
+                            .describe('Context data for template processing'),
+                    }),
+                },
+            },
+        },
+    },
+    responses: {
+        200: {
+            description: 'Streamed chat completion',
+            headers: z.object({
+                'Content-Type': z.string().default('text/plain; charset=utf-8'),
+                'x-vercel-ai-data-stream': z.string().default('v1'),
+            }),
+        },
+        ...commonGetErrorResponses,
+    },
+});
+// Apply context validation middleware
+app.use('/chat', contextValidationMiddleware(dbClient));
+app.openapi(chatDataStreamRoute, async (c) => {
+    try {
+        // Get execution context from API key authentication
+        const executionContext = getRequestExecutionContext(c);
+        const { tenantId, projectId, graphId } = executionContext;
+        const body = await c.req.valid('json');
+        const conversationId = body.conversationId || nanoid();
+        // Add conversation ID to parent span
+        const activeSpan = trace.getActiveSpan();
+        if (activeSpan) {
+            activeSpan.setAttributes({
+                'conversation.id': conversationId,
+                'tenant.id': tenantId,
+                'graph.id': graphId,
+                'project.id': projectId,
+            });
+        }
+        const agentGraph = await getAgentGraphWithDefaultAgent(dbClient)({
+            scopes: { tenantId, projectId },
+            graphId,
+        });
+        if (!agentGraph) {
+            return c.json({ error: 'Agent graph not found' }, 404);
+        }
+        const defaultAgentId = agentGraph.defaultAgentId;
+        const graphName = agentGraph.name;
+        const activeAgent = await getActiveAgentForConversation(dbClient)({
+            scopes: { tenantId, projectId },
+            conversationId,
+        });
+        if (!activeAgent) {
+            setActiveAgentForConversation(dbClient)({
+                scopes: { tenantId, projectId },
+                conversationId,
+                agentId: defaultAgentId,
+            });
+        }
+        const agentId = activeAgent?.activeAgentId || defaultAgentId;
+        const agentInfo = await getAgentById(dbClient)({
+            scopes: { tenantId, projectId },
+            agentId: agentId,
+        });
+        if (!agentInfo) {
+            return c.json({ error: 'Agent not found' }, 404);
+        }
+        // Get validated context from middleware (falls back to body.context if no validation)
+        const validatedContext = c.get('validatedContext') || body.requestContext || {};
+        const credentialStores = c.get('credentialStores');
+        // Context resolution with intelligent conversation state detection
+        await handleContextResolution(tenantId, projectId, conversationId, graphId, validatedContext, dbClient, credentialStores);
+        // Store last user message
+        const lastUserMessage = body.messages.filter((m) => m.role === 'user').slice(-1)[0];
+        const userText = typeof lastUserMessage?.content === 'string'
+            ? lastUserMessage.content
+            : lastUserMessage?.parts?.map((p) => p.text).join('') || '';
+        logger.info({ userText, lastUserMessage }, 'userText');
+        const messageSpan = trace.getActiveSpan();
+        if (messageSpan) {
+            messageSpan.setAttributes({
+                'message.timestamp': new Date().toISOString(),
+                'message.content': userText,
+                'graph.name': graphName,
+            });
+        }
+        await createMessage(dbClient)({
+            id: nanoid(),
+            tenantId,
+            projectId,
+            conversationId,
+            role: 'user',
+            content: { text: userText },
+            visibility: 'user-facing',
+            messageType: 'chat',
+        });
+        if (messageSpan) {
+            messageSpan.addEvent('user.message.stored', {
+                'message.id': conversationId,
+                'database.operation': 'insert',
+            });
+        }
+        // Create UI Message Stream using AI SDK V5
+        const dataStream = createUIMessageStream({
+            execute: async ({ writer }) => {
+                const streamHelper = createVercelStreamHelper(writer);
+                try {
+                    const executionHandler = new ExecutionHandler();
+                    const result = await executionHandler.execute({
+                        executionContext,
+                        conversationId,
+                        userMessage: userText,
+                        initialAgentId: agentId,
+                        requestId: `chatds-${Date.now()}`,
+                        sseHelper: streamHelper,
+                    });
+                    if (!result.success) {
+                        await streamHelper.writeError('Unable to process request');
+                    }
+                }
+                catch (err) {
+                    logger.error({ err }, 'Streaming error');
+                    await streamHelper.writeError('Internal server error');
+                }
+                finally {
+                    // Clean up stream helper resources if it has cleanup method
+                    if ('cleanup' in streamHelper && typeof streamHelper.cleanup === 'function') {
+                        streamHelper.cleanup();
+                    }
+                }
+            },
+        });
+        c.header('content-type', 'text/event-stream');
+        c.header('cache-control', 'no-cache');
+        c.header('connection', 'keep-alive');
+        c.header('x-vercel-ai-data-stream', 'v2');
+        c.header('x-accel-buffering', 'no'); // disable nginx buffering
+        return stream(c, (stream) => stream.pipe(dataStream.pipeThrough(new JsonToSseTransformStream()).pipeThrough(new TextEncoderStream())));
+    }
+    catch (error) {
+        logger.error({ error }, 'chatDataStream error');
+        return c.json({ error: 'Failed to process chat completion' }, 500);
+    }
+});
+export default app;

package/dist/routes/mcp.d.ts

@@ -0,0 +1,10 @@
+import { OpenAPIHono } from '@hono/zod-openapi';
+import { type CredentialStoreRegistry } from '@inkeep/agents-core';
+type AppVariables = {
+    credentialStores: CredentialStoreRegistry;
+};
+declare const app: OpenAPIHono<{
+    Variables: AppVariables;
+}, {}, "/">;
+export default app;
+//# sourceMappingURL=mcp.d.ts.map

package/dist/routes/mcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../src/routes/mcp.ts"],"names":[],"mappings":"AACA,OAAO,EAAe,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAa7D,OAAO,EACL,KAAK,uBAAuB,EAS7B,MAAM,qBAAqB,CAAC;AAgX7B,KAAK,YAAY,GAAG;IAClB,gBAAgB,EAAE,uBAAuB,CAAC;CAC3C,CAAC;AAEF,QAAA,MAAM,GAAG;eAAgC,YAAY;WAAK,CAAC;AA6T3D,eAAe,GAAG,CAAC"}