@inkeep/agents-manage-api 0.1.2 → 0.1.7

package/dist/data/tools.d.ts

@@ -1,82 +0,0 @@
-import { type McpServerCapabilities, type McpTool, type McpToolDefinition, type McpToolStatus, type CredentialStoreRegistry } from '@inkeep/agents-core';
-export declare const updateToolHealth: ({ tenantId, projectId, toolId, status, error, }: {
-    tenantId: string;
-    projectId: string;
-    toolId: string;
-    status: McpToolStatus;
-    error?: string;
-}) => Promise<{
-    tenantId: string;
-    projectId: string;
-    id: string;
-    name: string;
-    createdAt: string;
-    updatedAt: string;
-    status: string;
-    config: {
-        type: "mcp";
-        mcp: import("@inkeep/agents-core").ToolMcpConfig;
-    };
-    credentialReferenceId: string | null;
-    headers: Record<string, string> | null;
-    imageUrl: string | null;
-    capabilities: import("@inkeep/agents-core").ToolServerCapabilities | null;
-    lastHealthCheck: string | null;
-    lastError: string | null;
-    availableTools: McpToolDefinition[] | null;
-    lastToolsSync: string | null;
-}>;
-export declare const checkToolHealth: (tool: McpTool, credentialStoreRegistry?: CredentialStoreRegistry) => Promise<{
-    status: McpToolStatus;
-    error?: string;
-    capabilities?: McpServerCapabilities;
-}>;
-export declare const discoverToolsFromServer: (tool: McpTool, credentialStoreRegistry?: CredentialStoreRegistry) => Promise<McpToolDefinition[]>;
-export declare const syncToolDefinitions: ({ tenantId, projectId, toolId, credentialStoreRegistry, }: {
-    tenantId: string;
-    projectId: string;
-    toolId: string;
-    credentialStoreRegistry?: CredentialStoreRegistry;
-}) => Promise<{
-    tenantId: string;
-    projectId: string;
-    id: string;
-    name: string;
-    createdAt: string;
-    updatedAt: string;
-    status: string;
-    config: {
-        type: "mcp";
-        mcp: import("@inkeep/agents-core").ToolMcpConfig;
-    };
-    credentialReferenceId: string | null;
-    headers: Record<string, string> | null;
-    imageUrl: string | null;
-    capabilities: import("@inkeep/agents-core").ToolServerCapabilities | null;
-    lastHealthCheck: string | null;
-    lastError: string | null;
-    availableTools: McpToolDefinition[] | null;
-    lastToolsSync: string | null;
-}>;
-export declare const checkAllToolsHealth: (tenantId: string, projectId: string, credentialStoreRegistry?: CredentialStoreRegistry) => Promise<PromiseSettledResult<{
-    tenantId: string;
-    projectId: string;
-    id: string;
-    name: string;
-    createdAt: string;
-    updatedAt: string;
-    status: string;
-    config: {
-        type: "mcp";
-        mcp: import("@inkeep/agents-core").ToolMcpConfig;
-    };
-    credentialReferenceId: string | null;
-    headers: Record<string, string> | null;
-    imageUrl: string | null;
-    capabilities: import("@inkeep/agents-core").ToolServerCapabilities | null;
-    lastHealthCheck: string | null;
-    lastError: string | null;
-    availableTools: McpToolDefinition[] | null;
-    lastToolsSync: string | null;
-}>[]>;
-//# sourceMappingURL=tools.d.ts.map

package/dist/data/tools.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../src/data/tools.ts"],"names":[],"mappings":"AAGA,OAAO,EAML,KAAK,qBAAqB,EAC1B,KAAK,OAAO,EACZ,KAAK,iBAAiB,EACtB,KAAK,aAAa,EAUlB,KAAK,uBAAuB,EAC7B,MAAM,qBAAqB,CAAC;AAgD7B,eAAO,MAAM,gBAAgB,GAAU,iDAMpC;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,aAAa,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;;;;;;;;;;;;;;;;;;;;EAmBA,CAAC;AAEF,eAAO,MAAM,eAAe,GAC1B,MAAM,OAAO,EACb,0BAA0B,uBAAuB,KAChD,OAAO,CAAC;IACT,MAAM,EAAE,aAAa,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,qBAAqB,CAAC;CACtC,CAqGA,CAAC;AAGF,eAAO,MAAM,uBAAuB,GAAU,MAAM,OAAO,EAAE,0BAA0B,uBAAuB,KAAG,OAAO,CAAC,iBAAiB,EAAE,CAuF3I,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAU,2DAKvC;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,uBAAuB,CAAC,EAAE,uBAAuB,CAAC;CACnD;;;;;;;;;;;;;;;;;;;;EA+CA,CAAC;AAGF,eAAO,MAAM,mBAAmB,GAAU,UAAU,MAAM,EAAE,WAAW,MAAM,EAAE,0BAA0B,uBAAuB;;;;;;;;;;;;;;;;;;;;KAiB/H,CAAC"}

package/dist/data/tools.js

@@ -1,271 +0,0 @@
-import { getLogger } from '../logger.js';
-import dbClient from './db/dbClient.js';
-import { McpClient, CredentialStuffer, getCredentialReference, updateTool, dbResultToMcpTool, listTools, getToolById, detectAuthenticationRequired, ContextResolver, } from '@inkeep/agents-core';
-/**
- * Extract input schema from MCP tool definition, handling multiple formats
- * Different MCP servers may use different schema structures:
- * - inputSchema (direct) - e.g., Notion MCP
- * - parameters.properties - e.g., some other MCP servers
- * - parameters (direct) - alternative format
- * - schema - another possible location
- */
-function extractInputSchema(toolDef) {
-    // Try different possible locations for the input schema
-    if (toolDef.inputSchema) {
-        return toolDef.inputSchema;
-    }
-    if (toolDef.parameters?.properties) {
-        return toolDef.parameters.properties;
-    }
-    if (toolDef.parameters && typeof toolDef.parameters === 'object') {
-        return toolDef.parameters;
-    }
-    if (toolDef.schema) {
-        return toolDef.schema;
-    }
-    // If none found, return empty object
-    return {};
-}
-const logger = getLogger('tools');
-// Helper function to convert McpTool to MCPToolConfig format for CredentialStuffer
-const convertToMCPToolConfig = (tool) => {
-    return {
-        id: tool.id,
-        name: tool.name,
-        description: tool.name, // Use name as description fallback
-        serverUrl: tool.config.mcp.server.url,
-        mcpType: tool.config.mcp.server.url.includes('api.nango.dev') ? 'nango' : 'generic',
-        transport: tool.config.mcp.transport,
-        headers: tool.headers,
-    };
-};
-// Health checking and monitoring
-export const updateToolHealth = async ({ tenantId, projectId, toolId, status, error, }) => {
-    const now = new Date().toISOString();
-    const updateData = {
-        status,
-        lastHealthCheck: now,
-        updatedAt: now,
-    };
-    if (error !== undefined) {
-        updateData.lastError = error;
-    }
-    const tool = await updateTool(dbClient)({
-        scopes: { tenantId, projectId },
-        toolId,
-        data: updateData,
-    });
-    return tool;
-};
-export const checkToolHealth = async (tool, credentialStoreRegistry) => {
-    try {
-        const transportType = tool.config.mcp.transport?.type || 'streamable_http';
-        const baseConfig = {
-            url: tool.config.mcp.server.url,
-        };
-        const credentialReferenceId = tool.credentialReferenceId;
-        let serverConfig;
-        // Build server config with credentials if available
-        if (credentialReferenceId) {
-            // Get credential store configuration
-            const credentialReference = await getCredentialReference(dbClient)({
-                scopes: { tenantId: tool.tenantId, projectId: tool.projectId },
-                id: credentialReferenceId,
-            });
-            if (!credentialReference) {
-                throw new Error(`Credential store not found: ${credentialReferenceId}`);
-            }
-            const storeReference = {
-                credentialStoreId: credentialReference.credentialStoreId,
-                retrievalParams: credentialReference.retrievalParams || {},
-            };
-            // Use CredentialStuffer to build proper config with auth headers
-            if (!credentialStoreRegistry) {
-                throw new Error('CredentialStoreRegistry is required for authenticated tools');
-            }
-            const contextResolver = new ContextResolver(tool.tenantId, tool.projectId, dbClient, credentialStoreRegistry);
-            const credentialStuffer = new CredentialStuffer(credentialStoreRegistry, contextResolver);
-            serverConfig = await credentialStuffer.buildMcpServerConfig({ tenantId: tool.tenantId, projectId: tool.projectId }, convertToMCPToolConfig(tool), storeReference);
-        }
-        else {
-            if (transportType === 'sse') {
-                serverConfig = {
-                    type: 'sse',
-                    url: baseConfig.url,
-                    activeTools: tool.config.mcp.activeTools,
-                    eventSourceInit: tool.config.mcp.transport?.eventSourceInit,
-                };
-            }
-            else {
-                serverConfig = {
-                    type: 'streamable_http',
-                    url: baseConfig.url,
-                    activeTools: tool.config.mcp.activeTools,
-                    requestInit: tool.config.mcp.transport?.requestInit,
-                    eventSourceInit: tool.config.mcp.transport?.eventSourceInit,
-                    reconnectionOptions: tool.config.mcp.transport?.reconnectionOptions,
-                    sessionId: tool.config.mcp.transport?.sessionId,
-                };
-            }
-        }
-        const client = new McpClient({
-            name: tool.name,
-            server: serverConfig,
-        });
-        await client.connect();
-        // Try to list tools to verify connection
-        await client.tools();
-        await client.disconnect();
-        return {
-            status: 'healthy',
-            capabilities: {
-                tools: true,
-                resources: false, // Could be enhanced to check actual capabilities
-                prompts: false,
-                logging: false,
-            },
-        };
-    }
-    catch (error) {
-        logger.error({ toolId: tool.id, error }, 'Tool health check failed');
-        // Check if error indicates authentication is required
-        if (error instanceof Error && (await detectAuthenticationRequired(tool, error))) {
-            return {
-                status: 'needs_auth',
-                error: 'Authentication required - OAuth login needed',
-            };
-        }
-        return {
-            status: 'unhealthy',
-            error: error instanceof Error ? error.message : 'Unknown error',
-        };
-    }
-};
-// Tool discovery
-export const discoverToolsFromServer = async (tool, credentialStoreRegistry) => {
-    try {
-        const credentialReferenceId = tool.credentialReferenceId;
-        let serverConfig;
-        // Build server config with credentials if available
-        if (credentialReferenceId) {
-            // Get credential store configuration
-            const credentialReference = await getCredentialReference(dbClient)({
-                scopes: { tenantId: tool.tenantId, projectId: tool.projectId },
-                id: credentialReferenceId,
-            });
-            if (!credentialReference) {
-                throw new Error(`Credential store not found: ${credentialReferenceId}`);
-            }
-            const storeReference = {
-                credentialStoreId: credentialReference.credentialStoreId,
-                retrievalParams: credentialReference.retrievalParams || {},
-            };
-            // Use CredentialStuffer to build proper config with auth headers
-            if (!credentialStoreRegistry) {
-                throw new Error('CredentialStoreRegistry is required for authenticated tools');
-            }
-            const contextResolver = new ContextResolver(tool.tenantId, tool.projectId, dbClient, credentialStoreRegistry);
-            const credentialStuffer = new CredentialStuffer(credentialStoreRegistry, contextResolver);
-            serverConfig = (await credentialStuffer.buildMcpServerConfig({ tenantId: tool.tenantId, projectId: tool.projectId }, convertToMCPToolConfig(tool), storeReference));
-        }
-        else {
-            // No credentials - build basic config
-            const transportType = tool.config.mcp.transport?.type || 'streamable_http';
-            if (transportType === 'sse') {
-                serverConfig = {
-                    type: 'sse',
-                    url: tool.config.mcp.server.url,
-                    activeTools: tool.config.mcp.activeTools,
-                    eventSourceInit: tool.config.mcp.transport?.eventSourceInit,
-                };
-            }
-            else {
-                serverConfig = {
-                    type: 'streamable_http',
-                    url: tool.config.mcp.server.url,
-                    activeTools: tool.config.mcp.activeTools,
-                    requestInit: tool.config.mcp.transport?.requestInit,
-                    eventSourceInit: tool.config.mcp.transport?.eventSourceInit,
-                    reconnectionOptions: tool.config.mcp.transport?.reconnectionOptions,
-                    sessionId: tool.config.mcp.transport?.sessionId,
-                };
-            }
-        }
-        const client = new McpClient({
-            name: tool.name,
-            server: serverConfig,
-        });
-        await client.connect();
-        // Get tools from the MCP client
-        const serverTools = await client.tools();
-        await client.disconnect();
-        // Convert to our format
-        const toolDefinitions = Object.entries(serverTools).map(([name, toolDef]) => ({
-            name,
-            description: toolDef.description || '',
-            inputSchema: extractInputSchema(toolDef),
-        }));
-        return toolDefinitions;
-    }
-    catch (error) {
-        logger.error({ toolId: tool.id, error }, 'Tool discovery failed');
-        throw error;
-    }
-};
-export const syncToolDefinitions = async ({ tenantId, projectId, toolId, credentialStoreRegistry, }) => {
-    const tool = await getToolById(dbClient)({ scopes: { tenantId, projectId }, toolId });
-    if (!tool) {
-        throw new Error(`Tool ${toolId} not found`);
-    }
-    const mcpTool = dbResultToMcpTool(tool);
-    try {
-        const availableTools = await discoverToolsFromServer(mcpTool, credentialStoreRegistry);
-        const updatedTool = await updateTool(dbClient)({
-            scopes: { tenantId, projectId },
-            toolId,
-            data: {
-                availableTools,
-                lastToolsSync: new Date().toISOString(),
-                status: 'healthy',
-                updatedAt: new Date().toISOString(),
-            },
-        });
-        return updatedTool;
-    }
-    catch (error) {
-        const toolNeedsAuth = error instanceof Error && (await detectAuthenticationRequired(mcpTool, error));
-        const now = new Date().toISOString();
-        const updatedTool = await updateTool(dbClient)({
-            scopes: { tenantId, projectId },
-            toolId,
-            data: {
-                availableTools: [],
-                lastToolsSync: new Date().toISOString(),
-                status: toolNeedsAuth ? 'needs_auth' : 'unhealthy',
-                lastError: toolNeedsAuth
-                    ? 'Authentication required - OAuth login needed'
-                    : error instanceof Error
-                        ? error.message
-                        : 'Tool sync failed',
-                lastHealthCheck: now,
-                updatedAt: now,
-            },
-        });
-        return updatedTool;
-    }
-};
-// Bulk health checking
-export const checkAllToolsHealth = async (tenantId, projectId, credentialStoreRegistry) => {
-    const toolsList = await listTools(dbClient)({ scopes: { tenantId, projectId } });
-    const results = await Promise.allSettled(toolsList.data.map(async (tool) => {
-        const healthResult = await checkToolHealth(dbResultToMcpTool(tool), credentialStoreRegistry);
-        return await updateToolHealth({
-            tenantId,
-            projectId: tool.projectId,
-            toolId: tool.id,
-            status: healthResult.status,
-            error: healthResult.error,
-        });
-    }));
-    return results;
-};

package/dist/env.d.ts

@@ -1,41 +0,0 @@
-import { z } from 'zod';
-declare const envSchema: z.ZodObject<{
-    NODE_ENV: z.ZodOptional<z.ZodEnum<{
-        development: "development";
-        production: "production";
-        test: "test";
-    }>>;
-    ENVIRONMENT: z.ZodOptional<z.ZodEnum<{
-        development: "development";
-        pentest: "pentest";
-        production: "production";
-        test: "test";
-    }>>;
-    DB_FILE_NAME: z.ZodDefault<z.ZodString>;
-    PORT: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
-    MANAGEMENT_PORT: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
-    AGENT_BASE_URL: z.ZodOptional<z.ZodString>;
-    LOG_LEVEL: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-        error: "error";
-        debug: "debug";
-        info: "info";
-        trace: "trace";
-        warn: "warn";
-    }>>>;
-    NANGO_SECRET_KEY: z.ZodOptional<z.ZodString>;
-    INKEEP_AGENTS_MANAGE_API_SECRET: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export declare const env: {
-    DB_FILE_NAME: string;
-    PORT: number;
-    MANAGEMENT_PORT: number;
-    LOG_LEVEL: "error" | "debug" | "info" | "trace" | "warn";
-    NODE_ENV?: "development" | "production" | "test" | undefined;
-    ENVIRONMENT?: "development" | "pentest" | "production" | "test" | undefined;
-    AGENT_BASE_URL?: string | undefined;
-    NANGO_SECRET_KEY?: string | undefined;
-    INKEEP_AGENTS_MANAGE_API_SECRET?: string | undefined;
-};
-export type Env = z.infer<typeof envSchema>;
-export {};
-//# sourceMappingURL=env.d.ts.map

package/dist/env.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../src/env.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAkCxB,QAAA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;iBAUb,CAAC;AAuBH,eAAO,MAAM,GAAG;;;;;;;;;;CAAa,CAAC;AAC9B,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC"}

package/dist/env.js

@@ -1,59 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import * as dotenv from 'dotenv';
-import { z } from 'zod';
-dotenv.config({ quiet: true });
-const nodeEnvSchema = z.enum(['development', 'production']).default('development');
-const environmentSchema = z.enum(['development', 'pentest', 'production', 'test']);
-const criticalEnv = z
-    .object({
-    ENVIRONMENT: environmentSchema,
-})
-    .parse(process.env);
-const loadEnvFile = () => {
-    // Priority of environment variables:
-    // 1. Existing process.env variables (highest priority)
-    // 2. Values from .env.{nodeEnv}.nonsecret file (lower priority)
-    // 3. Default values defined in schema (lowest priority)
-    const envPath = path.resolve(process.cwd(), `.env.${criticalEnv.ENVIRONMENT}.nonsecret`);
-    if (fs.existsSync(envPath)) {
-        const envConfig = dotenv.parse(fs.readFileSync(envPath));
-        for (const k in envConfig) {
-            // Only set if the environment variable doesn't already exist
-            // This preserves any values that were already set in process.env
-            if (!(k in process.env)) {
-                process.env[k] = envConfig[k];
-            }
-        }
-    }
-};
-loadEnvFile();
-const envSchema = z.object({
-    NODE_ENV: z.enum(['development', 'production', 'test']).optional(),
-    ENVIRONMENT: z.enum(['development', 'production', 'pentest', 'test']).optional(),
-    DB_FILE_NAME: z.string().default('file:../local.db'),
-    PORT: z.coerce.number().optional().default(3002),
-    MANAGEMENT_PORT: z.coerce.number().optional().default(3002),
-    AGENT_BASE_URL: z.string().optional(),
-    LOG_LEVEL: z.enum(['trace', 'debug', 'info', 'warn', 'error']).optional().default('debug'),
-    NANGO_SECRET_KEY: z.string().optional(),
-    INKEEP_AGENTS_MANAGE_API_SECRET: z.string().optional(),
-});
-const parseEnv = () => {
-    try {
-        const parsedEnv = envSchema.parse(process.env);
-        // Set default AGENT_BASE_URL if not provided
-        if (!parsedEnv.AGENT_BASE_URL) {
-            parsedEnv.AGENT_BASE_URL = `http://localhost:${parsedEnv.PORT}`;
-        }
-        return parsedEnv;
-    }
-    catch (error) {
-        if (error instanceof z.ZodError) {
-            const missingVars = error.issues.map((issue) => issue.path.join('.'));
-            throw new Error(`❌ Invalid environment variables: ${missingVars.join(', ')}\n${error.message}`);
-        }
-        throw error;
-    }
-};
-export const env = parseEnv();

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAChD,OAAO,EACL,uBAAuB,EAEvB,KAAK,eAAe,EACpB,KAAK,YAAY,EAClB,MAAM,qBAAqB,CAAC;AAiB7B,QAAA,MAAM,GAAG;;;;;WAAuD,CAAC;AAGjE,eAAe,GAAG,CAAC;AAGnB,OAAO,EAAE,oBAAoB,EAAE,CAAC;AAGhC,wBAAgB,mBAAmB,CAAC,MAAM,CAAC,EAAE;IAC3C,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,gBAAgB,CAAC,EAAE,eAAe,EAAE,CAAC;CACtC;;;;;YAMA"}

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.js';
-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/auth.d.ts

@@ -1,12 +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, {}>;
-//# sourceMappingURL=auth.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/middleware/auth.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,gBAAgB,EAAa,MAAM,qBAAqB,CAAC;AAIvE;;;;GAIG;AACH,eAAO,MAAM,UAAU;eAER;QACT,gBAAgB,EAAE,gBAAgB,CAAC;KACpC;cA6BD,CAAC"}

package/dist/middleware/auth.js

@@ -1,36 +0,0 @@
-import { createMiddleware } from 'hono/factory';
-import { HTTPException } from 'hono/http-exception';
-import { getLogger } from '@inkeep/agents-core';
-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) => {
-    // If bypass secret is configured, only allow bypass authentication
-    if (env.INKEEP_AGENTS_MANAGE_API_SECRET) {
-        const authHeader = c.req.header('Authorization');
-        // 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 (apiKey === env.INKEEP_AGENTS_MANAGE_API_SECRET) {
-            logger.info({}, 'Bypass secret authenticated successfully');
-            await next();
-            return;
-        }
-        else {
-            // Bypass secret is set but token doesn't match - reject
-            throw new HTTPException(401, {
-                message: 'Invalid Token',
-            });
-        }
-    }
-    await next();
-    return;
-});

package/dist/openapi.d.ts

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

package/dist/openapi.d.ts.map

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

package/dist/openapi.js

@@ -1,38 +0,0 @@
-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 Agent Framework Management API',
-                    version: '1.0.0',
-                    description: 'Complete REST API for Inkeep Agent Framework Management application including chat completions, A2A agent communication, and comprehensive CRUD operations for all entities',
-                },
-                servers: [
-                    {
-                        url: env.MANAGEMENT_PORT
-                            ? `http://localhost:${env.MANAGEMENT_PORT}`
-                            : `http://localhost:3002`,
-                        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: 'InkeepAgent Framework Management API Documentation',
-    }));
-}

package/dist/routes/agentArtifactComponents.d.ts

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

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

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