@inkeep/agents-run-api 0.1.0

package/dist/middleware/api-key-auth.js

@@ -0,0 +1,139 @@
+import { createMiddleware } from 'hono/factory';
+import { HTTPException } from 'hono/http-exception';
+import { validateAndGetApiKey, getLogger } from '@inkeep/agents-core';
+import dbClient from '../data/db/dbClient.js';
+import { createExecutionContext } from '../types/execution-context.js';
+import { env } from '../env.js';
+const logger = getLogger('env-key-auth');
+/**
+ * Middleware to authenticate API requests using Bearer token authentication
+ * First checks if token matches INKEEP_AGENTS_RUN_BYPASS_SECRET, then falls back to API key validation
+ * Extracts and validates API keys, then adds execution context to the request
+ */
+export const apiKeyAuth = () => createMiddleware(async (c, next) => {
+    const authHeader = c.req.header('Authorization');
+    const tenantId = c.req.header('x-inkeep-tenant-id');
+    const projectId = c.req.header('x-inkeep-project-id');
+    const graphId = c.req.header('x-inkeep-graph-id');
+    const agentId = c.req.header('x-inkeep-agent-id');
+    const baseUrl = new URL(c.req.url).origin;
+    // Bypass authentication only for integration tests with specific header
+    if (process.env.ENVIRONMENT === 'development' || process.env.ENVIRONMENT === 'test') {
+        const executionContext = createExecutionContext({
+            apiKey: 'development',
+            tenantId: tenantId || 'test-tenant',
+            projectId: projectId || 'test-project',
+            graphId: graphId || 'test-graph',
+            apiKeyId: 'test-key',
+            baseUrl: baseUrl,
+            agentId: agentId,
+        });
+        c.set('executionContext', executionContext);
+        logger.info({}, 'Test environment bypass authenticated successfully');
+        await next();
+        return;
+    }
+    // Check for Bearer token
+    if (!authHeader || !authHeader.startsWith('Bearer ')) {
+        throw new HTTPException(401, {
+            message: 'Missing or invalid authorization header. Expected: Bearer <api_key>',
+        });
+    }
+    const apiKey = authHeader.substring(7); // Remove 'Bearer ' prefix
+    // If bypass secret is configured, allow bypass authentication or api key validation
+    if (env.INKEEP_AGENTS_RUN_BYPASS_SECRET) {
+        if (apiKey === env.INKEEP_AGENTS_RUN_BYPASS_SECRET) {
+            // Extract base URL from request
+            if (!tenantId || !projectId || !graphId) {
+                throw new HTTPException(401, {
+                    message: 'Missing or invalid tenant, project, or graph ID',
+                });
+            }
+            // Create bypass execution context with default values
+            const executionContext = createExecutionContext({
+                apiKey: apiKey,
+                tenantId: tenantId,
+                projectId: projectId,
+                graphId: graphId,
+                apiKeyId: 'bypass',
+                baseUrl: baseUrl,
+                agentId: agentId,
+            });
+            c.set('executionContext', executionContext);
+            logger.info({}, 'Bypass secret authenticated successfully');
+            await next();
+            return;
+        }
+        else if (apiKey) {
+            const executionContext = await extractContextFromApiKey(apiKey);
+            c.set('executionContext', executionContext);
+            logger.info({}, 'API key authenticated successfully');
+            await next();
+            return;
+        }
+        else {
+            // Bypass secret is set but token doesn't match - reject
+            throw new HTTPException(401, {
+                message: 'Invalid Token',
+            });
+        }
+    }
+    // No bypass secret configured - continue with normal API key validation
+    // Validate API key format (basic validation)
+    if (!apiKey || apiKey.length < 16) {
+        throw new HTTPException(401, {
+            message: 'Invalid API key format',
+        });
+    }
+    try {
+        const executionContext = await extractContextFromApiKey(apiKey);
+        c.set('executionContext', executionContext);
+        // Log successful authentication (without sensitive data)
+        logger.debug({
+            tenantId: executionContext.tenantId,
+            projectId: executionContext.projectId,
+            graphId: executionContext.graphId,
+        }, 'API key authenticated successfully');
+        await next();
+    }
+    catch (error) {
+        // Re-throw HTTPException
+        if (error instanceof HTTPException) {
+            throw error;
+        }
+        // Log unexpected errors and return generic message
+        logger.error({ error }, 'API key authentication error');
+        throw new HTTPException(500, {
+            message: 'Authentication failed',
+        });
+    }
+});
+export const extractContextFromApiKey = async (apiKey) => {
+    const apiKeyRecord = await validateAndGetApiKey(apiKey, dbClient);
+    if (!apiKeyRecord) {
+        throw new HTTPException(401, {
+            message: 'Invalid or expired API key',
+        });
+    }
+    return createExecutionContext({
+        apiKey: apiKey,
+        tenantId: apiKeyRecord.tenantId,
+        projectId: apiKeyRecord.projectId,
+        graphId: apiKeyRecord.graphId,
+        apiKeyId: apiKeyRecord.id,
+    });
+};
+/**
+ * Helper middleware for endpoints that optionally support API key authentication
+ * If no auth header is present, it continues without setting the executionContext
+ */
+export const optionalAuth = () => createMiddleware(async (c, next) => {
+    const authHeader = c.req.header('Authorization');
+    // If no auth header, continue without authentication
+    if (!authHeader || !authHeader.startsWith('Bearer ')) {
+        await next();
+        return;
+    }
+    // If auth header exists, use the regular auth middleware
+    return apiKeyAuth()(c, next);
+});

package/dist/middleware/index.d.ts

@@ -0,0 +1,2 @@
+export * from './api-key-auth.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/middleware/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/middleware/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC"}

package/dist/middleware/index.js

@@ -0,0 +1 @@
+export * from './api-key-auth.js';

package/dist/openapi.d.ts

@@ -0,0 +1,2 @@
+export declare function setupOpenAPIRoutes(app: any): void;
+//# sourceMappingURL=openapi.d.ts.map

package/dist/openapi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi.d.ts","sourceRoot":"","sources":["../src/openapi.ts"],"names":[],"mappings":"AAIA,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,GAAG,QAsC1C"}

package/dist/openapi.js

@@ -0,0 +1,36 @@
+import { swaggerUI } from '@hono/swagger-ui';
+import { env } from './env.js';
+export function setupOpenAPIRoutes(app) {
+    // OpenAPI specification endpoint - serves the complete API spec
+    app.get('/openapi.json', (c) => {
+        try {
+            const document = app.getOpenAPIDocument({
+                openapi: '3.0.0',
+                info: {
+                    title: 'Inkeep Execution API',
+                    version: '1.0.0',
+                    description: 'Complete REST API for Inkeep Execution application including chat completions, A2A agent communication, and comprehensive CRUD operations for all entities',
+                },
+                servers: [
+                    {
+                        url: env.AGENT_BASE_URL || `http://localhost:3003`,
+                        description: 'Development server',
+                    },
+                ],
+            });
+            return c.json(document);
+        }
+        catch (error) {
+            console.error('OpenAPI document generation failed:', error);
+            const errorDetails = error instanceof Error
+                ? { message: error.message, stack: error.stack }
+                : JSON.stringify(error, null, 2);
+            return c.json({ error: 'Failed to generate OpenAPI document', details: errorDetails }, 500);
+        }
+    });
+    // Swagger UI endpoint for interactive documentation
+    app.get('/docs', swaggerUI({
+        url: '/openapi.json',
+        title: 'Inkeep Execution API Documentation',
+    }));
+}

package/dist/routes/agents.d.ts

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

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

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

package/dist/routes/agents.js

@@ -0,0 +1,155 @@
+import { createRoute, OpenAPIHono } from '@hono/zod-openapi';
+import { z } from 'zod';
+import { a2aHandler } from '../a2a/handlers.js';
+import { getAgentGraphWithDefaultAgent, getRequestExecutionContext, HeadersScopeSchema, } from '@inkeep/agents-core';
+import { getRegisteredGraph } from '../data/agentGraph.js';
+import { getRegisteredAgent } from '../data/agents.js';
+import { getLogger } from '../logger.js';
+import dbClient from '../data/db/dbClient.js';
+const app = new OpenAPIHono();
+const logger = getLogger('agents');
+// A2A Agent Card Discovery (REST with OpenAPI)
+app.openapi(createRoute({
+    method: 'get',
+    path: '/.well-known/agent.json',
+    request: {
+        headers: HeadersScopeSchema,
+    },
+    tags: ['a2a'],
+    security: [{ bearerAuth: [] }],
+    responses: {
+        200: {
+            description: 'Agent Card for A2A discovery',
+            content: {
+                'application/json': {
+                    schema: z.object({
+                        name: z.string(),
+                        description: z.string().optional(),
+                        url: z.string(),
+                        version: z.string(),
+                        defaultInputModes: z.array(z.string()),
+                        defaultOutputModes: z.array(z.string()),
+                        skills: z.array(z.any()),
+                    }),
+                },
+            },
+        },
+        404: {
+            description: 'Agent not found',
+        },
+    },
+}), async (c) => {
+    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: well-known agent.json');
+    // Get execution context from API key authentication
+    const executionContext = getRequestExecutionContext(c);
+    const { tenantId, projectId, graphId, agentId } = executionContext;
+    // If agentId is defined in execution context, run agent-level logic
+    if (agentId) {
+        logger.info({
+            message: 'getRegisteredAgent (agent-level)',
+            tenantId,
+            projectId,
+            graphId,
+            agentId,
+        }, 'agent-level well-known agent.json');
+        const agent = await getRegisteredAgent(executionContext);
+        logger.info({ agent }, 'agent registered: well-known agent.json');
+        if (!agent) {
+            return c.json({ error: 'Agent not found' }, 404);
+        }
+        return c.json(agent.agentCard);
+    }
+    else {
+        // Run graph-level logic
+        logger.info({
+            message: 'getRegisteredGraph (graph-level)',
+            tenantId,
+            projectId,
+            graphId,
+        }, 'graph-level well-known agent.json');
+        const graph = await getRegisteredGraph(executionContext);
+        if (!graph) {
+            return c.json({ error: 'Graph not found' }, 404);
+        }
+        return c.json(graph.agentCard);
+    }
+});
+// A2A Protocol Handler (supports both agent-level and graph-level)
+app.post('/a2a', async (c) => {
+    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: a2a');
+    // Get execution context from API key authentication
+    const executionContext = getRequestExecutionContext(c);
+    const { tenantId, projectId, graphId, agentId } = executionContext;
+    // If agentId is defined in execution context, run agent-level logic
+    if (agentId) {
+        logger.info({
+            message: 'a2a (agent-level)',
+            tenantId,
+            projectId,
+            graphId,
+            agentId,
+        }, 'agent-level a2a endpoint');
+        // Ensure agent is registered (lazy loading)
+        const agent = await getRegisteredAgent(executionContext);
+        if (!agent) {
+            return c.json({
+                jsonrpc: '2.0',
+                error: { code: -32004, message: 'Agent not found' },
+                id: null,
+            }, 404);
+        }
+        return a2aHandler(c, agent);
+    }
+    else {
+        // Run graph-level logic
+        logger.info({
+            message: 'a2a (graph-level)',
+            tenantId,
+            projectId,
+            graphId,
+        }, 'graph-level a2a endpoint');
+        // fetch the graph and the default agent
+        const graph = await getAgentGraphWithDefaultAgent(dbClient)({
+            scopes: { tenantId, projectId },
+            graphId,
+        });
+        if (!graph) {
+            return c.json({
+                jsonrpc: '2.0',
+                error: { code: -32004, message: 'Agent not found' },
+                id: null,
+            }, 404);
+        }
+        executionContext.agentId = graph.defaultAgentId;
+        // fetch the default agent and use it as entry point for the graph
+        const defaultAgent = await getRegisteredAgent(executionContext);
+        if (!defaultAgent) {
+            return c.json({
+                jsonrpc: '2.0',
+                error: { code: -32004, message: 'Agent not found' },
+                id: null,
+            }, 404);
+        }
+        // Use the existing a2aHandler with the default agent as a registered agent
+        return a2aHandler(c, defaultAgent);
+    }
+});
+export default app;

package/dist/routes/chat.d.ts

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

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

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

package/dist/routes/chat.js

@@ -0,0 +1,308 @@
+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

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