@inkeep/agents-run-api 0.1.2 → 0.1.6

package/dist/routes/chat.js

@@ -1,308 +0,0 @@
-import { createRoute, OpenAPIHono } from '@hono/zod-openapi';
-// import { Hono } from 'hono';
-import { trace } from '@opentelemetry/api';
-import { streamSSE } from 'hono/streaming';
-import { nanoid } from 'nanoid';
-import { z } from 'zod';
-import { handleContextResolution } from '@inkeep/agents-core';
-import { createMessage, createOrGetConversation, getAgentById, getAgentGraphWithDefaultAgent, getActiveAgentForConversation, setActiveAgentForConversation, getFullGraph, getRequestExecutionContext, } from '@inkeep/agents-core';
-import { ExecutionHandler } from '../handlers/executionHandler.js';
-import { getLogger } from '../logger.js';
-import { contextValidationMiddleware } from '@inkeep/agents-core';
-import { createSSEStreamHelper } from '../utils/stream-helpers.js';
-import dbClient from '../data/db/dbClient.js';
-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 || {};
-        // Context resolution with intelligent conversation state detection
-        await handleContextResolution(tenantId, projectId, conversationId, graphId, validatedContext, dbClient);
-        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

@@ -1,4 +0,0 @@
-import { OpenAPIHono } from '@hono/zod-openapi';
-declare const app: OpenAPIHono<import("hono").Env, {}, "/">;
-export default app;
-//# sourceMappingURL=chatDataStream.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"chatDataStream.d.ts","sourceRoot":"","sources":["../../src/routes/chatDataStream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,WAAW,EAAK,MAAM,mBAAmB,CAAC;AAsBhE,QAAA,MAAM,GAAG,0CAAoB,CAAC;AAqM9B,eAAe,GAAG,CAAC"}

package/dist/routes/chatDataStream.js

@@ -1,179 +0,0 @@
-import { createRoute, OpenAPIHono, z } from '@hono/zod-openapi';
-import { trace } from '@opentelemetry/api';
-import { createUIMessageStream, JsonToSseTransformStream } from 'ai';
-import { stream } from 'hono/streaming';
-import { nanoid } from 'nanoid';
-import { handleContextResolution } from '@inkeep/agents-core';
-import { createMessage, getAgentById, getActiveAgentForConversation, setActiveAgentForConversation, getAgentGraphWithDefaultAgent, contextValidationMiddleware, commonGetErrorResponses, getRequestExecutionContext, } from '@inkeep/agents-core';
-import { ExecutionHandler } from '../handlers/executionHandler.js';
-import { getLogger } from '../logger.js';
-import { createVercelStreamHelper } from '../utils/stream-helpers.js';
-import dbClient from '../data/db/dbClient.js';
-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 || {};
-        // Context resolution with intelligent conversation state detection
-        await handleContextResolution(tenantId, projectId, conversationId, graphId, validatedContext, dbClient);
-        // 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');
-                }
-            },
-        });
-        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

@@ -1,4 +0,0 @@
-import { OpenAPIHono } from '@hono/zod-openapi';
-declare const app: OpenAPIHono<import("hono").Env, {}, "/">;
-export default app;
-//# sourceMappingURL=mcp.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../src/routes/mcp.ts"],"names":[],"mappings":"AACA,OAAO,EAAe,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAmY7D,QAAA,MAAM,GAAG,0CAAoB,CAAC;AAwT9B,eAAe,GAAG,CAAC"}