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

package/dist/routes/mcp.js

@@ -0,0 +1,500 @@
+import { createRoute, OpenAPIHono } from '@hono/zod-openapi';
+import { contextValidationMiddleware, HeadersScopeSchema } from '@inkeep/agents-core';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { z } from 'zod/v3';
+// Type bridge for MCP SDK compatibility with Zod v4
+function createMCPSchema(schema) {
+    return schema;
+}
+import { createMessage, createOrGetConversation, getAgentById, getAgentGraphWithDefaultAgent, getConversation, getRequestExecutionContext, handleContextResolution, updateConversation, } from '@inkeep/agents-core';
+import { trace } from '@opentelemetry/api';
+import { toFetchResponse, toReqRes } from 'fetch-to-node';
+import { nanoid } from 'nanoid';
+import dbClient from '../data/db/dbClient';
+import { ExecutionHandler } from '../handlers/executionHandler';
+import { getLogger } from '../logger';
+import { createMCPStreamHelper } from '../utils/stream-helpers';
+const logger = getLogger('mcp');
+/**
+ * Singleton mock response object for spoof initialization
+ */
+class MockResponseSingleton {
+    static instance;
+    mockRes;
+    constructor() {
+        // Create the mock response object once
+        this.mockRes = {
+            statusCode: 200,
+            headers: {},
+            setHeader: function (name, value) {
+                this.headers[name] = value;
+            },
+            getHeaders: function () {
+                return this.headers;
+            },
+            end: () => { },
+            write: () => { },
+            writeHead: () => { },
+        };
+    }
+    static getInstance() {
+        if (!MockResponseSingleton.instance) {
+            MockResponseSingleton.instance = new MockResponseSingleton();
+        }
+        return MockResponseSingleton.instance;
+    }
+    getMockResponse() {
+        // Reset headers for each use to avoid state pollution
+        this.mockRes.headers = {};
+        this.mockRes.statusCode = 200;
+        return this.mockRes;
+    }
+}
+/**
+ * Creates a spoof initialization message with the given protocol version
+ * Extracted as a pure function for better testability and reuse
+ */
+const createSpoofInitMessage = (mcpProtocolVersion) => ({
+    method: 'initialize',
+    params: {
+        protocolVersion: mcpProtocolVersion || '2025-06-18',
+        capabilities: {
+            tools: true,
+            prompts: true,
+            resources: false,
+            logging: false,
+            roots: { listChanged: false },
+        },
+        clientInfo: {
+            name: 'inkeep-mcp-server',
+            version: '1.0.0',
+        },
+    },
+    jsonrpc: '2.0',
+    id: 0,
+});
+/**
+ * Spoofs an initialization message to set the transport's initialized flag
+ * This is necessary when recreating transports for existing sessions because the transport expects to have received an initialization message from the client.
+ */
+const spoofTransportInitialization = async (transport, req, sessionId, mcpProtocolVersion) => {
+    logger.info({ sessionId }, 'Spoofing initialization message to set transport state');
+    const spoofInitMessage = createSpoofInitMessage(mcpProtocolVersion);
+    const mockRes = MockResponseSingleton.getInstance().getMockResponse();
+    try {
+        // Send the spoof initialization to set internal state. The transport errors but it still sets the initialized flag.
+        await transport.handleRequest(req, mockRes, spoofInitMessage);
+        logger.info({ sessionId }, 'Successfully spoofed initialization');
+    }
+    catch (spoofError) {
+        logger.warn({ sessionId, error: spoofError }, 'Spoof initialization failed, continuing anyway');
+    }
+};
+const validateSession = async (req, res, body, tenantId, projectId, graphId) => {
+    const sessionId = req.headers['mcp-session-id'];
+    logger.info({ sessionId }, 'Received MCP session ID');
+    if (!sessionId) {
+        logger.info({ body }, 'Missing session ID');
+        res.writeHead(400).end(JSON.stringify({
+            jsonrpc: '2.0',
+            error: { code: -32602, message: 'Bad Request: Mcp-Session-Id header is required' },
+            id: null,
+        }));
+        return false;
+    }
+    else if (Array.isArray(sessionId)) {
+        res.writeHead(400).end(JSON.stringify({
+            jsonrpc: '2.0',
+            error: {
+                code: -32000,
+                message: 'Bad Request: Mcp-Session-Id header must be a single value',
+            },
+            id: null,
+        }));
+        return false;
+    }
+    // Get conversation (which stores our session data)
+    const conversation = await getConversation(dbClient)({
+        scopes: { tenantId, projectId },
+        conversationId: sessionId,
+    });
+    // After line 342 - Add logging to debug conversation lookup
+    logger.info({
+        sessionId,
+        conversationFound: !!conversation,
+        sessionType: conversation?.metadata?.sessionData?.sessionType,
+        storedGraphId: conversation?.metadata?.sessionData?.graphId,
+        requestGraphId: graphId,
+    }, 'Conversation lookup result');
+    if (!conversation ||
+        conversation.metadata?.sessionData?.sessionType !== 'mcp' ||
+        conversation.metadata?.sessionData?.graphId !== graphId) {
+        logger.info({ sessionId, conversationId: conversation?.id }, 'MCP session not found or invalid');
+        res.writeHead(404).end(JSON.stringify({
+            jsonrpc: '2.0',
+            error: {
+                code: -32001,
+                message: 'Session not found',
+            },
+            id: null,
+        }));
+        return false;
+    }
+    return conversation;
+};
+/**
+ * Sets up tracing attributes for the active span
+ */
+const setupTracing = (conversationId, tenantId, graphId) => {
+    const activeSpan = trace.getActiveSpan();
+    if (activeSpan) {
+        activeSpan.setAttributes({
+            'conversation.id': conversationId,
+            'tenant.id': tenantId,
+            'graph.id': graphId,
+        });
+    }
+};
+/**
+ * Processes and stores the user message
+ */
+const processUserMessage = async (tenantId, projectId, conversationId, query) => {
+    const messageSpan = trace.getActiveSpan();
+    if (messageSpan) {
+        messageSpan.setAttributes({
+            'message.content': query,
+            'message.timestamp': Date.now(),
+        });
+    }
+    await createMessage(dbClient)({
+        id: nanoid(),
+        tenantId,
+        projectId,
+        conversationId,
+        role: 'user',
+        content: {
+            text: query,
+        },
+        visibility: 'user-facing',
+        messageType: 'chat',
+    });
+};
+/**
+ * Executes the agent query and returns the result
+ */
+const executeAgentQuery = async (executionContext, conversationId, query, defaultAgentId) => {
+    const requestId = `mcp-${Date.now()}`;
+    const mcpStreamHelper = createMCPStreamHelper();
+    const executionHandler = new ExecutionHandler();
+    const result = await executionHandler.execute({
+        executionContext,
+        conversationId,
+        userMessage: query,
+        initialAgentId: defaultAgentId,
+        requestId,
+        sseHelper: mcpStreamHelper,
+    });
+    logger.info({ result }, `Execution completed: ${result.success ? 'success' : 'failed'} after ${result.iterations} iterations`);
+    if (!result.success) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: result.error ||
+                        `Sorry, I was unable to process your request at this time. Please try again.`,
+                },
+            ],
+            isError: true,
+        };
+    }
+    return {
+        content: [
+            {
+                type: 'text',
+                text: result.response || 'No response generated',
+            },
+        ],
+    };
+};
+/**
+ * Creates and configures an MCP server for the given context
+ */
+const getServer = async (requestContext, executionContext, conversationId, credentialStores) => {
+    const { tenantId, projectId, graphId } = executionContext;
+    setupTracing(conversationId, tenantId, graphId);
+    const agentGraph = await getAgentGraphWithDefaultAgent(dbClient)({
+        scopes: { tenantId, projectId },
+        graphId: graphId,
+    });
+    if (!agentGraph) {
+        throw new Error('Agent graph not found');
+    }
+    const server = new McpServer({
+        name: 'inkeep-chat-api-server',
+        version: '1.0.0',
+    }, { capabilities: { logging: {} } });
+    // Register tools and prompts
+    server.tool('send-query-to-agent', `Send a query to the ${agentGraph.name} agent. The agent has the following description: ${agentGraph.description}`, {
+        query: createMCPSchema(z.string().describe('The query to send to the agent')),
+    }, async ({ query }) => {
+        try {
+            const defaultAgentId = agentGraph.defaultAgentId;
+            const agentInfo = await getAgentById(dbClient)({
+                scopes: { tenantId, projectId },
+                agentId: defaultAgentId,
+            });
+            if (!agentInfo) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Agent not found`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            const resolvedContext = await handleContextResolution(tenantId, projectId, conversationId, graphId, requestContext, dbClient, credentialStores);
+            logger.info({
+                tenantId,
+                graphId,
+                conversationId,
+                hasContextConfig: !!agentGraph.contextConfigId,
+                hasRequestContext: !!requestContext,
+                hasValidatedContext: !!resolvedContext,
+            }, 'parameters');
+            await processUserMessage(tenantId, projectId, conversationId, query);
+            return executeAgentQuery(executionContext, conversationId, query, defaultAgentId);
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error sending query: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    return server;
+};
+const app = new OpenAPIHono();
+// Only apply context validation to POST requests (GET requests are for SSE streams)
+app.use('/', async (c, next) => {
+    if (c.req.method === 'POST') {
+        return contextValidationMiddleware(dbClient)(c, next);
+    }
+    return next();
+});
+/**
+ * Validates request parameters and returns execution context if valid
+ */
+const validateRequestParameters = (c) => {
+    try {
+        const executionContext = getRequestExecutionContext(c);
+        const { tenantId, projectId, graphId } = executionContext;
+        getLogger('mcp').debug({ tenantId, projectId, graphId }, 'Extracted MCP entity parameters');
+        return { valid: true, executionContext };
+    }
+    catch (error) {
+        getLogger('chat').warn({ error: error instanceof Error ? error.message : 'Unknown error' }, 'Failed to get execution context');
+        return {
+            valid: false,
+            response: c.json({
+                jsonrpc: '2.0',
+                error: { code: -32602, message: 'API key authentication required' },
+                id: null,
+            }, { status: 401 }),
+        };
+    }
+};
+/**
+ * Creates a new MCP session and handles initialization
+ */
+const handleInitializationRequest = async (body, executionContext, validatedContext, req, res, c, credentialStores) => {
+    const { tenantId, projectId, graphId } = executionContext;
+    logger.info({ body }, 'Received initialization request');
+    const sessionId = nanoid();
+    // Get the default agent for the graph
+    const agentGraph = await getAgentGraphWithDefaultAgent(dbClient)({
+        scopes: { tenantId, projectId },
+        graphId,
+    });
+    if (!agentGraph) {
+        return c.json({
+            jsonrpc: '2.0',
+            error: { code: -32001, message: 'Agent graph not found' },
+            id: body.id || null,
+        }, { status: 404 });
+    }
+    // Create/get conversation with MCP session metadata
+    const conversation = await createOrGetConversation(dbClient)({
+        id: sessionId,
+        tenantId,
+        projectId,
+        activeAgentId: agentGraph.defaultAgentId,
+        metadata: {
+            sessionData: {
+                graphId,
+                sessionType: 'mcp',
+                mcpProtocolVersion: c.req.header('mcp-protocol-version'),
+                initialized: false, // Track initialization state
+            },
+        },
+    });
+    logger.info({ sessionId, conversationId: conversation.id }, 'Created MCP session as conversation');
+    // Create fresh transport and server for this request
+    const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: () => sessionId,
+    });
+    const server = await getServer(validatedContext, executionContext, sessionId, credentialStores);
+    await server.connect(transport);
+    logger.info({ sessionId }, 'Server connected for initialization');
+    // Tell client the session ID
+    res.setHeader('Mcp-Session-Id', sessionId);
+    logger.info({
+        sessionId,
+        bodyMethod: body?.method,
+        bodyId: body?.id,
+    }, 'About to handle initialization request');
+    await transport.handleRequest(req, res, body);
+    logger.info({ sessionId }, 'Successfully handled initialization request');
+    return toFetchResponse(res);
+};
+/**
+ * Handles requests for existing MCP sessions
+ */
+const handleExistingSessionRequest = async (body, executionContext, validatedContext, req, res, credentialStores) => {
+    const { tenantId, projectId, graphId } = executionContext;
+    // Validate the session id
+    const conversation = await validateSession(req, res, body, tenantId, projectId, graphId);
+    if (!conversation) {
+        return toFetchResponse(res);
+    }
+    const sessionId = conversation.id;
+    // Update last activity
+    await updateConversation(dbClient)({
+        scopes: { tenantId, projectId },
+        conversationId: sessionId,
+        data: {
+        // Just updating the timestamp by calling update
+        },
+    });
+    // Recreate transport and server from stored session data
+    const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: () => sessionId,
+    });
+    const server = await getServer(validatedContext, executionContext, sessionId, credentialStores);
+    await server.connect(transport);
+    // Spoof initialization to set the transport's _initialized flag
+    await spoofTransportInitialization(transport, req, sessionId, conversation.metadata?.session_data?.mcpProtocolVersion);
+    logger.info({ sessionId }, 'Server connected and transport initialized');
+    // Add debugging before transport.handleRequest()
+    logger.info({
+        sessionId,
+        bodyKeys: Object.keys(body || {}),
+        bodyMethod: body?.method,
+        bodyId: body?.id,
+        requestHeaders: Object.fromEntries(Object.entries(req.headers || {}).filter(([k]) => k.startsWith('mcp-'))),
+    }, 'About to handle MCP request with existing session');
+    try {
+        await transport.handleRequest(req, res, body);
+        logger.info({ sessionId }, 'Successfully handled MCP request');
+    }
+    catch (transportError) {
+        logger.error({
+            sessionId,
+            error: transportError,
+            errorMessage: transportError instanceof Error ? transportError.message : 'Unknown error',
+        }, 'Transport handleRequest failed');
+        throw transportError; // Re-throw to be caught by outer catch
+    }
+    return toFetchResponse(res);
+};
+/**
+ * Creates a JSON-RPC error response
+ */
+const createErrorResponse = (code, message, id = null) => ({
+    jsonrpc: '2.0',
+    error: { code, message },
+    id,
+});
+app.openapi(createRoute({
+    method: 'post',
+    path: '/',
+    tags: ['MCP'],
+    summary: 'MCP Protocol',
+    description: 'Handles Model Context Protocol (MCP) JSON-RPC requests',
+    security: [{ bearerAuth: [] }],
+    request: {
+        headers: HeadersScopeSchema,
+    },
+    responses: {
+        200: {
+            description: 'MCP response',
+        },
+        401: {
+            description: 'Unauthorized - API key authentication required',
+        },
+        404: {
+            description: 'Not Found - Agent graph not found',
+        },
+        500: {
+            description: 'Internal Server Error',
+        },
+    },
+}), async (c) => {
+    try {
+        // Validate parameters
+        const paramValidation = validateRequestParameters(c);
+        if (!paramValidation.valid) {
+            return paramValidation.response;
+        }
+        const { executionContext } = paramValidation;
+        const body = await c.req.json();
+        logger.info({ body, bodyKeys: Object.keys(body || {}) }, 'Parsed request body');
+        const isInitRequest = body.method === 'initialize';
+        const { req, res } = toReqRes(c.req.raw);
+        const validatedContext = c.get('validatedContext') || {};
+        const credentialStores = c.get('credentialStores');
+        logger.info({ validatedContext }, 'Validated context');
+        logger.info({ req }, 'request');
+        if (isInitRequest) {
+            return await handleInitializationRequest(body, executionContext, validatedContext, req, res, c, credentialStores);
+        }
+        else {
+            return await handleExistingSessionRequest(body, executionContext, validatedContext, req, res, credentialStores);
+        }
+    }
+    catch (e) {
+        logger.error({
+            error: e instanceof Error ? e.message : e,
+            stack: e instanceof Error ? e.stack : undefined,
+        }, 'MCP request error');
+        return c.json(createErrorResponse(-32603, 'Internal server error'), { status: 500 });
+    }
+});
+app.get('/', async (c) => {
+    logger.info('Received GET MCP request');
+    return c.json({
+        jsonrpc: '2.0',
+        error: {
+            code: -32000,
+            message: 'Method not allowed.',
+        },
+        id: null,
+    }, { status: 405 });
+});
+// We want to maintain conversations in the database. (https://modelcontextprotocol.io/specification/2025-03-26/basic/transports#session-management)
+app.delete('/', async (c) => {
+    logger.info('Received DELETE MCP request');
+    return c.json({
+        jsonrpc: '2.0',
+        error: { code: -32001, message: 'Method Not Allowed' },
+        id: null,
+    }, { status: 405 });
+});
+export default app;

package/dist/tracer.d.ts

@@ -0,0 +1,24 @@
+import { type Span, type Tracer } from '@opentelemetry/api';
+export declare const BASE = "inkeep-chat";
+export declare const SERVICE_NAME = "inkeep-chat";
+export declare const SERVICE_VERSION = "1.0.0";
+export declare const createSpanName: (suffix: string) => string;
+/**
+ * Helper function to handle span errors consistently
+ * Records the exception, sets error status, and optionally logs
+ */
+export declare function handleSpanError(span: Span, error: unknown, logger?: {
+    error: (obj: any, msg?: string) => void;
+}, logMessage?: string): void;
+/**
+ * Get the global tracer instance
+ * This creates a single tracer for the entire application
+ */
+export declare function getGlobalTracer(): Tracer;
+/**
+ * Force flush the tracer provider to ensure critical spans are sent immediately
+ * This is useful for critical operations where we want to ensure telemetry data
+ * is sent before the operation completes or fails
+ */
+export declare function forceFlushTracer(): Promise<void>;
+//# sourceMappingURL=tracer.d.ts.map

package/dist/tracer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tracer.d.ts","sourceRoot":"","sources":["../src/tracer.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,IAAI,EAGT,KAAK,MAAM,EAEZ,MAAM,oBAAoB,CAAC;AAU5B,eAAO,MAAM,IAAI,gBAAgB,CAAC;AAGlC,eAAO,MAAM,YAAY,gBAAgB,CAAC;AAC1C,eAAO,MAAM,eAAe,UAAU,CAAC;AAGvC,eAAO,MAAM,cAAc,GAAI,QAAQ,MAAM,WAAwB,CAAC;AAyCtE;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,OAAO,EACd,MAAM,CAAC,EAAE;IAAE,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;CAAE,EACpD,UAAU,CAAC,EAAE,MAAM,GAClB,IAAI,CAgBN;AAED;;;GAGG;AACH,wBAAgB,eAAe,IAAI,MAAM,CAUxC;AAED;;;;GAIG;AACH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAwBtD"}

package/dist/tracer.js

@@ -0,0 +1,107 @@
+import { SpanStatusCode, trace, } from '@opentelemetry/api';
+import { env } from './env';
+import { getLogger } from './logger';
+// Environments where trace force flush should be enabled
+const FORCE_FLUSH_ENVIRONMENTS = ['development'];
+const logger = getLogger('tracer');
+// Base prefix for all span names - export this to use in other files
+export const BASE = 'inkeep-chat';
+// Service name and version constants for consistent tracer identification
+export const SERVICE_NAME = 'inkeep-chat';
+export const SERVICE_VERSION = '1.0.0';
+// Helper function to create prefixed span names
+export const createSpanName = (suffix) => `${BASE}.${suffix}`;
+// No-op span implementation for when OpenTelemetry is not available
+const createNoOpSpan = () => ({
+    setAttributes: () => ({}),
+    recordException: () => ({}),
+    setStatus: () => ({}),
+    addEvent: () => ({}),
+    end: () => { },
+    isRecording: () => false,
+    setAttribute: () => ({}),
+    updateName: () => ({}),
+    spanContext: () => ({
+        traceId: '00000000000000000000000000000000',
+        spanId: '0000000000000000',
+        traceFlags: 0,
+    }),
+    addLink: () => ({}),
+    addLinks: () => ({}),
+});
+// No-op tracer implementation for when OpenTelemetry is not available
+const noopTracer = {
+    startActiveSpan(_name, arg1, arg2, arg3) {
+        const fn = typeof arg1 === 'function' ? arg1 : typeof arg2 === 'function' ? arg2 : arg3;
+        if (!fn)
+            throw new Error('No callback function provided');
+        return fn(createNoOpSpan());
+    },
+    startSpan(_name, _options) {
+        return createNoOpSpan();
+    },
+};
+// Global tracer instance - singleton pattern
+let globalTracerInstance = null;
+/**
+ * Helper function to handle span errors consistently
+ * Records the exception, sets error status, and optionally logs
+ */
+export function handleSpanError(span, error, logger, logMessage) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    // Record the exception in the span
+    span.recordException(error);
+    // Set error status
+    span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: errorMessage,
+    });
+    // Optionally log the error
+    if (logger && logMessage) {
+        logger.error({ error: errorMessage }, logMessage);
+    }
+}
+/**
+ * Get the global tracer instance
+ * This creates a single tracer for the entire application
+ */
+export function getGlobalTracer() {
+    if (!globalTracerInstance) {
+        try {
+            globalTracerInstance = trace.getTracer(SERVICE_NAME, SERVICE_VERSION);
+        }
+        catch (_error) {
+            logger.debug('OpenTelemetry tracer not available, using no-op tracer');
+            globalTracerInstance = noopTracer;
+        }
+    }
+    return globalTracerInstance;
+}
+/**
+ * Force flush the tracer provider to ensure critical spans are sent immediately
+ * This is useful for critical operations where we want to ensure telemetry data
+ * is sent before the operation completes or fails
+ */
+export async function forceFlushTracer() {
+    const isOtelTracesForceFlushEnabled = env.OTEL_TRACES_FORCE_FLUSH_ENABLED;
+    const isForceFlushEnvironment = env.ENVIRONMENT && FORCE_FLUSH_ENVIRONMENTS.includes(env.ENVIRONMENT);
+    const shouldForceFlush = isOtelTracesForceFlushEnabled === true ||
+        (isOtelTracesForceFlushEnabled == null && isForceFlushEnvironment);
+    if (!shouldForceFlush) {
+        return;
+    }
+    try {
+        // Import the span processor from instrumentation
+        const { spanProcessor } = await import('./instrumentation.js');
+        if (spanProcessor && typeof spanProcessor.forceFlush === 'function') {
+            await spanProcessor.forceFlush();
+            logger.debug('Span processor force flush completed');
+        }
+        else {
+            logger.debug('Span processor does not support force flush or is not available');
+        }
+    }
+    catch (error) {
+        logger.warn({ error }, 'Failed to force flush tracer');
+    }
+}

package/dist/types/chat.d.ts

@@ -0,0 +1,25 @@
+export type ContentItem = {
+    type: string;
+    text?: string;
+};
+export type Message = {
+    role: 'system' | 'user' | 'assistant' | 'function' | 'tool';
+    content: string | ContentItem[];
+    name?: string;
+};
+export type ChatCompletionRequest = {
+    model: string;
+    messages: Message[];
+    temperature?: number;
+    top_p?: number;
+    n?: number;
+    stream?: boolean;
+    max_tokens?: number;
+    presence_penalty?: number;
+    frequency_penalty?: number;
+    logit_bias?: Record<string, number>;
+    user?: string;
+    tools?: Record<string, unknown>;
+    runConfig?: Record<string, unknown>;
+};
+//# sourceMappingURL=chat.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chat.d.ts","sourceRoot":"","sources":["../../src/types/chat.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG;IACpB,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,WAAW,GAAG,UAAU,GAAG,MAAM,CAAC;IAC5D,OAAO,EAAE,MAAM,GAAG,WAAW,EAAE,CAAC;IAChC,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACrC,CAAC"}

package/dist/types/chat.js

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

package/dist/types/execution-context.d.ts

@@ -0,0 +1,14 @@
+import type { ExecutionContext } from '@inkeep/agents-core';
+/**
+ * Create execution context from middleware values
+ */
+export declare function createExecutionContext(params: {
+    apiKey: string;
+    tenantId: string;
+    projectId: string;
+    graphId: string;
+    apiKeyId: string;
+    agentId?: string;
+    baseUrl?: string;
+}): ExecutionContext;
+//# sourceMappingURL=execution-context.d.ts.map

package/dist/types/execution-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution-context.d.ts","sourceRoot":"","sources":["../../src/types/execution-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE;IAC7C,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GAAG,gBAAgB,CAUnB"}