@inkeep/agents-run-api 0.1.3 → 0.1.6

package/dist/handlers/executionHandler.js

@@ -1,399 +0,0 @@
-import { createMessage, createTask, getActiveAgentForConversation, getFullGraph, getTask, updateTask, } from '@inkeep/agents-core';
-import { trace } from '@opentelemetry/api';
-import { nanoid } from 'nanoid';
-import { A2AClient } from '../a2a/client';
-import { executeTransfer, isTransferResponse } from '../a2a/transfer';
-import dbClient from '../data/db/dbClient';
-import { getLogger } from '../logger';
-import { agentInitializingOp, agentReadyOp, agentThinkingOp, completionOp, errorOp, } from '../utils/agent-operations';
-import { graphSessionManager } from '../utils/graph-session';
-import { MCPStreamHelper } from '../utils/stream-helpers';
-import { registerStreamHelper, unregisterStreamHelper } from '../utils/stream-registry';
-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));
-            await sseHelper.writeOperation(agentReadyOp(requestId, graphId));
-            // Send agent thinking operation after ready
-            await sseHelper.writeOperation(agentThinkingOp('system'));
-            // Check for existing task first to prevent race conditions
-            const taskId = `task_${conversationId}-${requestId}`;
-            const existingTask = await getTask(dbClient)({ id: taskId });
-            if (existingTask) {
-                // Task already exists, use it instead of creating a new one
-                task = existingTask;
-                logger.info({ taskId, existingTask }, 'Reusing existing task to prevent race condition');
-            }
-            else {
-                // Task creation (data operations removed)
-                // Create initial task
-                logger.info({ taskId, currentAgentId, conversationId, requestId }, 'About to create task with streamRequestId');
-                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');
-            }
-            // 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));
-                    // 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.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,mBAAmB,CAAC;AAC3B,OAAO,EACL,KAAK,eAAe,EACpB,uBAAuB,EAEvB,KAAK,YAAY,EAClB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,mBAAmB,EAAE,MAAM,OAAO,CAAC;AAiB5C,QAAA,MAAM,GAAG;;;;;;WAAsD,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;;;;;;YAMA"}

package/dist/instrumentation.d.ts

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

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

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

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

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

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

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

@@ -1 +0,0 @@
-{"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"}