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

package/dist/handlers/executionHandler.js

@@ -0,0 +1,415 @@
+import { createMessage, createTask, getActiveAgentForConversation, getFullGraph, getTask, updateTask, } from '@inkeep/agents-core';
+import { trace } from '@opentelemetry/api';
+import { A2AClient } from '../a2a/client.js';
+import { executeTransfer, isTransferResponse } from '../a2a/transfer.js';
+import { getLogger } from '../logger.js';
+import { agentInitializingOp, completionOp, errorOp } from '../utils/agent-operations.js';
+import { graphSessionManager } from '../utils/graph-session.js';
+import { MCPStreamHelper } from '../utils/stream-helpers.js';
+import { registerStreamHelper, unregisterStreamHelper } from '../utils/stream-registry.js';
+import dbClient from '../data/db/dbClient.js';
+import { nanoid } from 'nanoid';
+const logger = getLogger('ExecutionHandler');
+export class ExecutionHandler {
+    // Hardcoded error limit - separate from configurable stopWhen
+    MAX_ERRORS = 3;
+    /**
+     * performs exeuction loop
+     *
+     * Do up to limit of MAX_ITERATIONS
+     *
+     * 1. lookup active agent for thread
+     * 2. Send A2A message to selected agent
+     * 3. Parse A2A message response
+     * 4. Handle transfer messages (if any)
+     * 5. Handle completion messages (if any)
+     * 6. If no valid response or transfer, return error
+     * @param params
+     * @returns
+     */
+    async execute(params) {
+        const { executionContext, conversationId, userMessage, initialAgentId, requestId, sseHelper } = params;
+        const { tenantId, projectId, graphId, apiKey, baseUrl } = executionContext;
+        // Register streamHelper so agents can access it via requestId
+        registerStreamHelper(requestId, sseHelper);
+        // Create GraphSession for this entire message execution using requestId as the session ID
+        graphSessionManager.createSession(requestId, graphId, tenantId, projectId);
+        logger.info({ sessionId: requestId, graphId }, 'Created GraphSession for message execution');
+        // Initialize status updates if configured
+        let graphConfig = null;
+        try {
+            graphConfig = await getFullGraph(dbClient)({ scopes: { tenantId, projectId }, graphId });
+            if (graphConfig?.statusUpdates && graphConfig.statusUpdates.enabled !== false) {
+                graphSessionManager.initializeStatusUpdates(requestId, graphConfig.statusUpdates, graphConfig.models?.summarizer);
+            }
+        }
+        catch (error) {
+            logger.error({
+                error: error instanceof Error ? error.message : 'Unknown error',
+                stack: error instanceof Error ? error.stack : undefined,
+            }, '❌ Failed to initialize status updates, continuing without them');
+        }
+        let currentAgentId = initialAgentId;
+        let iterations = 0;
+        let errorCount = 0;
+        let task = null;
+        let fromAgentId; // Track the agent that executed a transfer
+        try {
+            // Send agent initializing and ready operations immediately to ensure UI rendering
+            await sseHelper.writeOperation(agentInitializingOp(requestId, graphId));
+            // Use atomic upsert pattern to handle race conditions properly
+            const taskId = `task_${conversationId}-${requestId}`;
+            logger.info({ taskId, currentAgentId, conversationId, requestId }, 'Attempting to create or reuse existing task');
+            try {
+                // Try to create the task atomically
+                task = await createTask(dbClient)({
+                    id: taskId,
+                    tenantId,
+                    projectId,
+                    agentId: currentAgentId,
+                    contextId: conversationId,
+                    status: 'pending',
+                    metadata: {
+                        conversation_id: conversationId,
+                        message_id: requestId,
+                        stream_request_id: requestId, // This also serves as the GraphSession ID
+                        created_at: new Date().toISOString(),
+                        updated_at: new Date().toISOString(),
+                        root_agent_id: initialAgentId,
+                        agent_id: currentAgentId,
+                    },
+                });
+                logger.info({
+                    taskId,
+                    createdTaskMetadata: Array.isArray(task) ? task[0]?.metadata : task?.metadata,
+                }, 'Task created with metadata');
+            }
+            catch (error) {
+                // Handle race condition: if task already exists due to concurrent request,
+                // fetch and reuse the existing task instead of failing
+                if (error?.message?.includes('UNIQUE constraint failed') ||
+                    error?.message?.includes('PRIMARY KEY constraint failed') ||
+                    error?.code === 'SQLITE_CONSTRAINT_PRIMARYKEY') {
+                    logger.info({ taskId, error: error.message }, 'Task already exists, fetching existing task');
+                    const existingTask = await getTask(dbClient)({ id: taskId });
+                    if (existingTask) {
+                        task = existingTask;
+                        logger.info({ taskId, existingTask }, 'Successfully reused existing task from race condition');
+                    }
+                    else {
+                        // This should not happen, but handle gracefully
+                        logger.error({ taskId, error }, 'Task constraint failed but task not found');
+                        throw error;
+                    }
+                }
+                else {
+                    // Re-throw non-constraint errors
+                    logger.error({ taskId, error }, 'Failed to create task due to non-constraint error');
+                    throw error;
+                }
+            }
+            // Debug logging for execution handler (structured logging only)
+            logger.debug({
+                timestamp: new Date().toISOString(),
+                executionType: 'create_initial_task',
+                conversationId,
+                requestId,
+                currentAgentId,
+                taskId: Array.isArray(task) ? task[0]?.id : task?.id,
+                userMessage: userMessage.substring(0, 100), // Truncate for security
+            }, 'ExecutionHandler: Initial task created');
+            // If createTask returns an array, get the first element
+            if (Array.isArray(task))
+                task = task[0];
+            let currentMessage = userMessage;
+            // Get transfer limit from graph configuration
+            const maxTransfers = graphConfig?.stopWhen?.transferCountIs ?? 10;
+            // Start execution loop
+            while (iterations < maxTransfers) {
+                iterations++;
+                // Stream iteration start
+                // Iteration start (data operations removed)
+                logger.info({ iterations, currentAgentId, graphId, conversationId, fromAgentId }, `Execution loop iteration ${iterations} with agent ${currentAgentId}, transfer from: ${fromAgentId || 'none'}`);
+                // Step 1: Determine which agent should handle the message
+                const activeAgent = await getActiveAgentForConversation(dbClient)({
+                    scopes: { tenantId, projectId },
+                    conversationId,
+                });
+                logger.info({ activeAgent }, 'activeAgent');
+                if (activeAgent && activeAgent.activeAgentId !== currentAgentId) {
+                    currentAgentId = activeAgent.activeAgentId;
+                    logger.info({ currentAgentId }, `Updated current agent to: ${currentAgentId}`);
+                    // Stream agent selection update
+                    // Agent selection (data operations removed)
+                }
+                // Step 2: Send A2A message to selected agent
+                const agentBaseUrl = `${baseUrl}/agents`;
+                const a2aClient = new A2AClient(agentBaseUrl, {
+                    headers: {
+                        Authorization: `Bearer ${apiKey}`,
+                        'x-inkeep-tenant-id': tenantId,
+                        'x-inkeep-project-id': projectId,
+                        'x-inkeep-graph-id': graphId,
+                        'x-inkeep-agent-id': currentAgentId,
+                    },
+                });
+                // Check if agent supports streaming
+                // const agentCard = await a2aClient.getAgentCard();
+                let messageResponse = null;
+                // Build message metadata - include fromAgentId only if this is a transfer
+                const messageMetadata = {
+                    stream_request_id: requestId, // This also serves as the GraphSession ID
+                };
+                if (fromAgentId) {
+                    messageMetadata.fromAgentId = fromAgentId;
+                }
+                messageResponse = await a2aClient.sendMessage({
+                    message: {
+                        role: 'user',
+                        parts: [
+                            {
+                                kind: 'text',
+                                text: currentMessage,
+                            },
+                        ],
+                        messageId: `${requestId}-iter-${iterations}`,
+                        kind: 'message',
+                        contextId: conversationId,
+                        metadata: messageMetadata,
+                    },
+                    configuration: {
+                        acceptedOutputModes: ['text', 'text/plain'],
+                        blocking: false,
+                    },
+                });
+                // Step 3: Parse A2A message response
+                if (!messageResponse?.result) {
+                    errorCount++;
+                    logger.error({ currentAgentId, iterations, errorCount }, `No response from agent ${currentAgentId} on iteration ${iterations} (error ${errorCount}/${this.MAX_ERRORS})`);
+                    // Check if we've hit the error limit
+                    if (errorCount >= this.MAX_ERRORS) {
+                        const errorMessage = `Maximum error limit (${this.MAX_ERRORS}) reached`;
+                        logger.error({ maxErrors: this.MAX_ERRORS, errorCount }, errorMessage);
+                        await sseHelper.writeError(errorMessage);
+                        await sseHelper.writeOperation(errorOp(errorMessage, currentAgentId || 'system'));
+                        if (task) {
+                            await updateTask(dbClient)({
+                                taskId: task.id,
+                                data: {
+                                    status: 'failed',
+                                    metadata: {
+                                        ...task.metadata,
+                                        failed_at: new Date().toISOString(),
+                                        error: errorMessage,
+                                    },
+                                },
+                            });
+                        }
+                        graphSessionManager.endSession(requestId);
+                        unregisterStreamHelper(requestId);
+                        return { success: false, error: errorMessage, iterations };
+                    }
+                    continue;
+                }
+                // Step 4: Handle transfer messages
+                if (isTransferResponse(messageResponse.result)) {
+                    const transferResponse = messageResponse.result;
+                    // Extract targetAgentId from transfer response artifacts
+                    const targetAgentId = transferResponse.artifacts?.[0]?.parts?.[0]?.data
+                        ?.targetAgentId;
+                    const transferReason = transferResponse.artifacts?.[0]?.parts?.[1]?.text;
+                    // Transfer operation (data operations removed)
+                    logger.info({ targetAgentId, transferReason }, 'transfer response');
+                    // Update the current message to the transfer reason so as not to duplicate the user message on every transfer
+                    // including the xml because the fromAgent does not always directly adress the toAgent in its text
+                    currentMessage = `<transfer_context> ${transferReason} </transfer_context>`;
+                    const { success, targetAgentId: newAgentId } = await executeTransfer({
+                        projectId,
+                        tenantId,
+                        threadId: conversationId,
+                        targetAgentId,
+                    });
+                    if (success) {
+                        // Set fromAgentId to track which agent executed this transfer
+                        fromAgentId = currentAgentId;
+                        currentAgentId = newAgentId;
+                        logger.info({
+                            transferFrom: fromAgentId,
+                            transferTo: currentAgentId,
+                            reason: transferReason,
+                        }, 'Transfer executed, tracking fromAgentId for next iteration');
+                    }
+                    // Continue to next iteration with new agent
+                    continue;
+                }
+                const responseParts = messageResponse.result.artifacts?.flatMap((artifact) => artifact.parts || []) || [];
+                if (responseParts && responseParts.length > 0) {
+                    // Log graph session data after completion response
+                    const graphSessionData = graphSessionManager.getSession(requestId);
+                    if (graphSessionData) {
+                        const sessionSummary = graphSessionData.getSummary();
+                        logger.info(sessionSummary, 'GraphSession data after completion');
+                    }
+                    // Process response parts for database storage and A2A protocol
+                    // NOTE: Do NOT stream content here - agents handle their own streaming
+                    let textContent = '';
+                    for (const part of responseParts) {
+                        const isTextPart = (part.kind === 'text' || part.type === 'text') && part.text;
+                        if (isTextPart) {
+                            textContent += part.text;
+                        }
+                        // Data parts are already processed by the agent's streaming logic
+                    }
+                    // Stream completion operation
+                    // Completion operation (data operations removed)
+                    const activeSpan = trace.getActiveSpan();
+                    if (activeSpan) {
+                        activeSpan.setAttributes({
+                            'ai.response.content': textContent || 'No response content',
+                            'ai.response.timestamp': new Date().toISOString(),
+                            'ai.agent.name': currentAgentId,
+                        });
+                    }
+                    // Store the agent response in the database with both text and parts
+                    await createMessage(dbClient)({
+                        id: nanoid(),
+                        tenantId,
+                        projectId,
+                        conversationId,
+                        role: 'agent',
+                        content: {
+                            text: textContent || undefined,
+                            parts: responseParts.map((part) => ({
+                                type: part.kind === 'text' ? 'text' : 'data',
+                                text: part.kind === 'text' ? part.text : undefined,
+                                data: part.kind === 'data' ? JSON.stringify(part.data) : undefined,
+                            })),
+                        },
+                        visibility: 'user-facing',
+                        messageType: 'chat',
+                        agentId: currentAgentId,
+                        fromAgentId: currentAgentId,
+                        taskId: task.id,
+                    });
+                    // Mark task as completed
+                    const updateTaskStart = Date.now();
+                    await updateTask(dbClient)({
+                        taskId: task.id,
+                        data: {
+                            status: 'completed',
+                            metadata: {
+                                ...task.metadata,
+                                completed_at: new Date().toISOString(),
+                                response: {
+                                    text: textContent,
+                                    parts: responseParts,
+                                    hasText: !!textContent,
+                                    hasData: responseParts.some((p) => p.kind === 'data'),
+                                },
+                            },
+                        },
+                    });
+                    const updateTaskEnd = Date.now();
+                    logger.info({ duration: updateTaskEnd - updateTaskStart }, 'Completed updateTask operation');
+                    // Send completion data operation before ending session
+                    await sseHelper.writeOperation(completionOp(currentAgentId, iterations));
+                    // Complete the stream to flush any queued operations
+                    await sseHelper.complete();
+                    // End the GraphSession and clean up resources
+                    logger.info('Ending GraphSession and cleaning up');
+                    graphSessionManager.endSession(requestId);
+                    // Clean up streamHelper
+                    logger.info('Cleaning up streamHelper');
+                    unregisterStreamHelper(requestId);
+                    // Extract captured response if using MCPStreamHelper
+                    let response;
+                    if (sseHelper instanceof MCPStreamHelper) {
+                        const captured = sseHelper.getCapturedResponse();
+                        response = captured.text || 'No response content';
+                    }
+                    logger.info('ExecutionHandler returning success');
+                    return { success: true, iterations, response };
+                }
+                // If we get here, we didn't get a valid response or transfer
+                errorCount++;
+                logger.warn({ iterations, errorCount }, `No valid response or transfer on iteration ${iterations} (error ${errorCount}/${this.MAX_ERRORS})`);
+                // Check if we've hit the error limit
+                if (errorCount >= this.MAX_ERRORS) {
+                    const errorMessage = `Maximum error limit (${this.MAX_ERRORS}) reached`;
+                    logger.error({ maxErrors: this.MAX_ERRORS, errorCount }, errorMessage);
+                    await sseHelper.writeError(errorMessage);
+                    await sseHelper.writeOperation(errorOp(errorMessage, currentAgentId || 'system'));
+                    if (task) {
+                        await updateTask(dbClient)({
+                            taskId: task.id,
+                            data: {
+                                status: 'failed',
+                                metadata: {
+                                    ...task.metadata,
+                                    failed_at: new Date().toISOString(),
+                                    error: errorMessage,
+                                },
+                            },
+                        });
+                    }
+                    graphSessionManager.endSession(requestId);
+                    unregisterStreamHelper(requestId);
+                    return { success: false, error: errorMessage, iterations };
+                }
+            }
+            // Max transfers reached
+            const errorMessage = `Maximum transfer limit (${maxTransfers}) reached without completion`;
+            logger.error({ maxTransfers, iterations }, errorMessage);
+            // Stream error operation
+            // Error operation (data operations removed)
+            await sseHelper.writeError(errorMessage);
+            // Send error operation for max iterations reached
+            await sseHelper.writeOperation(errorOp(errorMessage, currentAgentId || 'system'));
+            // Mark task as failed
+            if (task) {
+                await updateTask(dbClient)({
+                    taskId: task.id,
+                    data: {
+                        status: 'failed',
+                        metadata: {
+                            ...task.metadata,
+                            failed_at: new Date().toISOString(),
+                            error: errorMessage,
+                        },
+                    },
+                });
+            }
+            // Clean up GraphSession and streamHelper on error
+            graphSessionManager.endSession(requestId);
+            unregisterStreamHelper(requestId);
+            return { success: false, error: errorMessage, iterations };
+        }
+        catch (error) {
+            logger.error({ error }, 'Error in execution handler');
+            const errorMessage = error instanceof Error ? error.message : 'Unknown execution error';
+            // Stream error operation
+            // Error operation (data operations removed)
+            await sseHelper.writeError(`Execution error: ${errorMessage}`);
+            // Send error operation for execution exception
+            await sseHelper.writeOperation(errorOp(errorMessage, currentAgentId || 'system'));
+            // Mark task as failed
+            if (task) {
+                await updateTask(dbClient)({
+                    taskId: task.id,
+                    data: {
+                        status: 'failed',
+                        metadata: {
+                            ...task.metadata,
+                            failed_at: new Date().toISOString(),
+                            error: errorMessage,
+                        },
+                    },
+                });
+            }
+            // Clean up GraphSession and streamHelper on exception
+            graphSessionManager.endSession(requestId);
+            unregisterStreamHelper(requestId);
+            return { success: false, error: errorMessage, iterations };
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import './instrumentation';
+import { type CredentialStore, type ServerConfig } from '@inkeep/agents-core';
+import { createExecutionHono } from './app';
+declare const app: import("hono").Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default app;
+export { createExecutionHono };
+export declare function createExecutionApp(config?: {
+    serverConfig?: ServerConfig;
+    credentialStores?: CredentialStore[];
+}): import("hono").Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,mBAAmB,CAAC;AAC3B,OAAO,EACL,KAAK,eAAe,EAGpB,KAAK,YAAY,EAClB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,mBAAmB,EAAE,MAAM,OAAO,CAAC;AAiB5C,QAAA,MAAM,GAAG,2FAAsD,CAAC;AAGhE,eAAe,GAAG,CAAC;AAGnB,OAAO,EAAE,mBAAmB,EAAE,CAAC;AAG/B,wBAAgB,kBAAkB,CAAC,MAAM,CAAC,EAAE;IAC1C,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,gBAAgB,CAAC,EAAE,eAAe,EAAE,CAAC;CACtC,6FAMA"}

package/dist/index.js

@@ -0,0 +1,28 @@
+import './instrumentation';
+import { CredentialStoreRegistry, createDefaultCredentialStores, } from '@inkeep/agents-core';
+import { createExecutionHono } from './app';
+// Create default configuration
+const defaultConfig = {
+    port: 3003,
+    serverOptions: {
+        requestTimeout: 120000, // 120 seconds for execution requests
+        keepAliveTimeout: 60000,
+        keepAlive: true,
+    },
+};
+// Create default credential stores
+const defaultStores = createDefaultCredentialStores();
+const defaultRegistry = new CredentialStoreRegistry(defaultStores);
+// Create default app instance for simple usage
+const app = createExecutionHono(defaultConfig, defaultRegistry);
+// Export the default app for Vite dev server and simple deployments
+export default app;
+// Also export the factory function for advanced usage
+export { createExecutionHono };
+// Export a helper to create app with custom credential stores - fallsback to default configs
+export function createExecutionApp(config) {
+    const serverConfig = config?.serverConfig ?? defaultConfig;
+    const stores = config?.credentialStores ?? defaultStores;
+    const registry = new CredentialStoreRegistry(stores);
+    return createExecutionHono(serverConfig, registry);
+}

package/dist/instrumentation.d.ts

@@ -0,0 +1,13 @@
+import { NodeSDK } from '@opentelemetry/sdk-node';
+declare class FanOutSpanProcessor {
+    private inner;
+    constructor(inner: any[]);
+    onStart(span: any, parent: any): void;
+    onEnd(span: any): void;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+declare const spanProcessor: FanOutSpanProcessor;
+export declare const sdk: NodeSDK;
+export { spanProcessor };
+//# sourceMappingURL=instrumentation.d.ts.map

package/dist/instrumentation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../src/instrumentation.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAOlD,cAAM,mBAAmB;IACX,OAAO,CAAC,KAAK;gBAAL,KAAK,EAAE,GAAG,EAAE;IAChC,OAAO,CAAC,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG;IAG9B,KAAK,CAAC,IAAI,EAAE,GAAG;IAGf,UAAU;IAGV,QAAQ;CAGT;AAED,QAAA,MAAM,aAAa,qBAQjB,CAAC;AAEH,eAAO,MAAM,GAAG,SAyBd,CAAC;AAGH,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/dist/instrumentation.js

@@ -0,0 +1,66 @@
+import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
+import { ALLOW_ALL_BAGGAGE_KEYS, BaggageSpanProcessor, } from '@opentelemetry/baggage-span-processor';
+import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-proto';
+import { NodeSDK } from '@opentelemetry/sdk-node';
+import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-node';
+const otlpUrl = process.env.OTEL_EXPORTER_OTLP_ENDPOINT || 'http://localhost:14318/v1/traces';
+const otlpExporter = new OTLPTraceExporter({ url: otlpUrl });
+// Minimal fan-out so NodeSDK can accept ONE spanProcessor
+class FanOutSpanProcessor {
+    inner;
+    constructor(inner) {
+        this.inner = inner;
+    }
+    onStart(span, parent) {
+        this.inner.forEach((p) => p.onStart(span, parent));
+    }
+    onEnd(span) {
+        this.inner.forEach((p) => p.onEnd(span));
+    }
+    forceFlush() {
+        return Promise.all(this.inner.map((p) => p.forceFlush?.())).then(() => { });
+    }
+    shutdown() {
+        return Promise.all(this.inner.map((p) => p.shutdown?.())).then(() => { });
+    }
+}
+const spanProcessor = new FanOutSpanProcessor([
+    new BaggageSpanProcessor(ALLOW_ALL_BAGGAGE_KEYS),
+    new BatchSpanProcessor(otlpExporter, {
+        maxExportBatchSize: 1, // Send immediately (vs 512)
+        scheduledDelayMillis: 100, // 100ms delay (vs 5000ms)
+        exportTimeoutMillis: 5000, // 5s timeout (vs 30s)
+        maxQueueSize: 512, // Smaller queue
+    }),
+]);
+export const sdk = new NodeSDK({
+    serviceName: 'inkeep-chat',
+    spanProcessor,
+    instrumentations: [
+        getNodeAutoInstrumentations({
+            '@opentelemetry/instrumentation-http': {
+                enabled: true,
+                requestHook: (span, request) => {
+                    const url = request?.url ?? request?.path;
+                    if (!url)
+                        return;
+                    const u = new URL(url, 'http://localhost');
+                    span.updateName(`${request?.method || 'UNKNOWN'} ${u.pathname}`);
+                },
+            },
+            '@opentelemetry/instrumentation-undici': {
+                requestHook: (span) => {
+                    const method = span.attributes?.['http.request.method'];
+                    const host = span.attributes?.['server.address'];
+                    const path = span.attributes?.['url.path'];
+                    if (method && path)
+                        span.updateName(host ? `${method} ${host}${path}` : `${method} ${path}`);
+                },
+            },
+        }),
+    ],
+});
+// Export the span processor for force flush access
+export { spanProcessor };
+// SDK starts automatically when imported
+sdk.start();

package/dist/logger.d.ts

@@ -0,0 +1,4 @@
+import type { Next } from 'hono';
+export declare function getLogger(name?: string): import("pino").Logger<never, boolean>;
+export declare function withRequestContext(reqId: string, fn: Next): Promise<void>;
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAwBjC,wBAAgB,SAAS,CAAC,IAAI,CAAC,EAAE,MAAM,yCAOtC;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,IAAI,iBAEzD"}

package/dist/logger.js

@@ -0,0 +1,32 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { pino } from 'pino';
+// import { createGcpLoggingPinoConfig } from '@google-cloud/pino-logging-gcp-config';
+import { env } from './env';
+const logger = pino({
+    level: env.LOG_LEVEL,
+    serializers: {
+        obj: (value) => ({ ...value }),
+    },
+    redact: ['req.headers.authorization', 'req.headers["x-inkeep-admin-authentication"]'],
+    transport: {
+        target: 'pino-pretty',
+        options: {
+            sync: true,
+            destination: 1, // stdout
+            colorize: true,
+            translateTime: 'SYS:standard',
+        },
+    },
+});
+const asyncLocalStorage = new AsyncLocalStorage();
+export function getLogger(name) {
+    const store = asyncLocalStorage.getStore();
+    const reqId = store?.get('requestId') || undefined;
+    if (!reqId) {
+        return logger.child({ name });
+    }
+    return logger.child({ reqId, name });
+}
+export function withRequestContext(reqId, fn) {
+    return asyncLocalStorage.run(new Map([['requestId', reqId]]), fn);
+}

package/dist/middleware/api-key-auth.d.ts

@@ -0,0 +1,22 @@
+import { type ExecutionContext } from '@inkeep/agents-core';
+/**
+ * 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 declare const apiKeyAuth: () => import("hono").MiddlewareHandler<{
+    Variables: {
+        executionContext: ExecutionContext;
+    };
+}, string, {}>;
+export declare const extractContextFromApiKey: (apiKey: string) => Promise<ExecutionContext>;
+/**
+ * Helper middleware for endpoints that optionally support API key authentication
+ * If no auth header is present, it continues without setting the executionContext
+ */
+export declare const optionalAuth: () => import("hono").MiddlewareHandler<{
+    Variables: {
+        executionContext?: ExecutionContext;
+    };
+}, string, {}>;
+//# sourceMappingURL=api-key-auth.d.ts.map

package/dist/middleware/api-key-auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-key-auth.d.ts","sourceRoot":"","sources":["../../src/middleware/api-key-auth.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,gBAAgB,EAAmC,MAAM,qBAAqB,CAAC;AAQ7F;;;;GAIG;AACH,eAAO,MAAM,UAAU;eAER;QACT,gBAAgB,EAAE,gBAAgB,CAAC;KACpC;cAoHD,CAAC;AAEL,eAAO,MAAM,wBAAwB,GAAU,QAAQ,MAAM,8BAgB5D,CAAC;AACF;;;GAGG;AACH,eAAO,MAAM,YAAY;eAEV;QACT,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;KACrC;cAYD,CAAC"}