@inkeep/agents-manage-api 0.1.0

package/dist/index.js

@@ -0,0 +1,42 @@
+import { ManagementServer } from './ManagementServer.js';
+import { InMemoryCredentialStore, createNangoCredentialStore, createKeyChainStore, } from '@inkeep/agents-core';
+import { env } from './env.js';
+import { getLogger } from './logger.js';
+const logger = getLogger('management-api');
+export const MANAGEMENT_API_PORT = 3002;
+// Create credential stores
+const credentialStores = [
+    new InMemoryCredentialStore('memory-default'), // In-memory store + env vars
+    // Nango store (only loads if NANGO_SECRET_KEY is set)
+    ...(process.env.NANGO_SECRET_KEY
+        ? [
+            createNangoCredentialStore('nango-default', {
+                apiUrl: process.env.NANGO_HOST || 'https://api.nango.dev',
+                secretKey: process.env.NANGO_SECRET_KEY,
+            }),
+        ]
+        : []),
+    createKeyChainStore('keychain-default'),
+];
+// Initialize Management Server
+export const managementServer = new ManagementServer({
+    port: MANAGEMENT_API_PORT,
+    credentialStores,
+    serverOptions: {
+        requestTimeout: 60000, // 60 seconds
+        keepAliveTimeout: 60000,
+        keepAlive: true,
+    },
+});
+// Start the server only if not in test environment
+if (env.ENVIRONMENT !== 'test') {
+    managementServer
+        .serve()
+        .then(() => {
+        logger.info(`📝 OpenAPI documentation available at http://localhost:${MANAGEMENT_API_PORT}/openapi.json`);
+    })
+        .catch((error) => {
+        logger.error('Failed to start Management API server:', error);
+        process.exit(1);
+    });
+}

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.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

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

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

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

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

package/dist/openapi.d.ts.map

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

package/dist/openapi.js

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

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

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

package/dist/routes/agentArtifactComponents.js

@@ -0,0 +1,230 @@
+import { createRoute, OpenAPIHono } from '@hono/zod-openapi';
+import { z } from 'zod';
+import { getAgentById } from '@inkeep/agents-core';
+import { commonGetErrorResponses, createApiError } from '@inkeep/agents-core';
+import { AgentArtifactComponentApiInsertSchema, AgentArtifactComponentApiSelectSchema, ErrorResponseSchema, SingleResponseSchema, TenantProjectParamsSchema, ArtifactComponentApiSelectSchema, associateArtifactComponentWithAgent, getAgentsUsingArtifactComponent, getArtifactComponentById, getArtifactComponentsForAgent, isArtifactComponentAssociatedWithAgent, removeArtifactComponentFromAgent, RemovedResponseSchema, ExistsResponseSchema, } from '@inkeep/agents-core';
+import dbClient from '../data/db/dbClient.js';
+const app = new OpenAPIHono();
+// List artifact components for a specific agent in a graph
+app.openapi(createRoute({
+    method: 'get',
+    path: '/agent/:agentId',
+    summary: 'Get Artifact Components for Agent',
+    operationId: 'get-artifact-components-for-agent',
+    tags: ['CRUD Agent Artifact Component Relations'],
+    request: {
+        params: TenantProjectParamsSchema.extend({
+            agentId: z.string(),
+        }),
+    },
+    responses: {
+        200: {
+            description: 'Artifact components retrieved successfully',
+            content: {
+                'application/json': {
+                    schema: z.object({
+                        data: z.array(ArtifactComponentApiSelectSchema),
+                    }),
+                },
+            },
+        },
+        ...commonGetErrorResponses,
+    },
+}), async (c) => {
+    const { tenantId, projectId, agentId } = c.req.valid('param');
+    const artifactComponents = await getArtifactComponentsForAgent(dbClient)({
+        scopes: { tenantId, projectId },
+        agentId,
+    });
+    return c.json({
+        data: artifactComponents,
+    });
+});
+// List agents using a specific artifact component
+app.openapi(createRoute({
+    method: 'get',
+    path: '/component/:artifactComponentId/agents',
+    summary: 'Get Agents Using Artifact Component',
+    operationId: 'get-agents-using-artifact-component',
+    tags: ['CRUD Agent Artifact Component Relations'],
+    request: {
+        params: TenantProjectParamsSchema.extend({
+            artifactComponentId: z.string(),
+        }),
+    },
+    responses: {
+        200: {
+            description: 'Agents retrieved successfully',
+            content: {
+                'application/json': {
+                    schema: z.object({
+                        data: z.array(z.object({
+                            agentId: z.string(),
+                            createdAt: z.string(),
+                        })),
+                    }),
+                },
+            },
+        },
+        ...commonGetErrorResponses,
+    },
+}), async (c) => {
+    const { tenantId, projectId, artifactComponentId } = c.req.valid('param');
+    const agents = await getAgentsUsingArtifactComponent(dbClient)({
+        scopes: { tenantId, projectId },
+        artifactComponentId,
+    });
+    return c.json({ data: agents });
+});
+// Create agent artifact component association
+app.openapi(createRoute({
+    method: 'post',
+    path: '/',
+    summary: 'Associate Artifact Component with Agent',
+    operationId: 'associate-artifact-component-with-agent',
+    tags: ['CRUD Agent Artifact Component Relations'],
+    request: {
+        params: TenantProjectParamsSchema,
+        body: {
+            content: {
+                'application/json': {
+                    schema: AgentArtifactComponentApiInsertSchema,
+                },
+            },
+        },
+    },
+    responses: {
+        201: {
+            description: 'Agent artifact component association created successfully',
+            content: {
+                'application/json': {
+                    schema: SingleResponseSchema(AgentArtifactComponentApiSelectSchema),
+                },
+            },
+        },
+        409: {
+            description: 'Association already exists',
+            content: {
+                'application/json': {
+                    schema: ErrorResponseSchema,
+                },
+            },
+        },
+        ...commonGetErrorResponses,
+    },
+}), async (c) => {
+    const { tenantId, projectId } = c.req.valid('param');
+    const { agentId, artifactComponentId } = c.req.valid('json');
+    // Validate that both agent and artifact component exist before creating association
+    const agent = await getAgentById(dbClient)({ scopes: { tenantId, projectId }, agentId });
+    const artifactComponent = await getArtifactComponentById(dbClient)({
+        scopes: { tenantId, projectId },
+        id: artifactComponentId,
+    });
+    if (!agent) {
+        throw createApiError({
+            code: 'not_found',
+            message: `Agent with id '${agentId}' not found`,
+        });
+    }
+    if (!artifactComponent) {
+        throw createApiError({
+            code: 'not_found',
+            message: `Artifact component with id '${artifactComponentId}' not found`,
+        });
+    }
+    // Check if association already exists
+    const exists = await isArtifactComponentAssociatedWithAgent(dbClient)({
+        scopes: { tenantId, projectId },
+        agentId,
+        artifactComponentId,
+    });
+    if (exists) {
+        throw createApiError({
+            code: 'conflict',
+            message: 'Agent artifact component association already exists',
+        });
+    }
+    const association = await associateArtifactComponentWithAgent(dbClient)({
+        scopes: { tenantId, projectId },
+        agentId,
+        artifactComponentId,
+    });
+    return c.json({ data: association }, 201);
+});
+// Remove agent artifact component association
+app.openapi(createRoute({
+    method: 'delete',
+    path: '/agent/:agentId/component/:artifactComponentId',
+    summary: 'Remove Artifact Component from Agent',
+    operationId: 'remove-artifact-component-from-agent',
+    tags: ['CRUD Agent Artifact Component Relations'],
+    request: {
+        params: TenantProjectParamsSchema.extend({
+            agentId: z.string(),
+            artifactComponentId: z.string(),
+        }),
+    },
+    responses: {
+        200: {
+            description: 'Association removed successfully',
+            content: {
+                'application/json': {
+                    schema: RemovedResponseSchema,
+                },
+            },
+        },
+        ...commonGetErrorResponses,
+    },
+}), async (c) => {
+    const { tenantId, projectId, agentId, artifactComponentId } = c.req.valid('param');
+    const removed = await removeArtifactComponentFromAgent(dbClient)({
+        scopes: { tenantId, projectId },
+        agentId,
+        artifactComponentId,
+    });
+    if (!removed) {
+        throw createApiError({
+            code: 'not_found',
+            message: 'Agent artifact component association not found',
+        });
+    }
+    return c.json({
+        message: 'Association removed successfully',
+        removed: true,
+    });
+});
+// Check if artifact component is associated with agent
+app.openapi(createRoute({
+    method: 'get',
+    path: '/agent/:agentId/component/:artifactComponentId/exists',
+    summary: 'Check if Artifact Component is Associated with Agent',
+    operationId: 'check-artifact-component-agent-association',
+    tags: ['CRUD Agent Artifact Component Relations'],
+    request: {
+        params: TenantProjectParamsSchema.extend({
+            agentId: z.string(),
+            artifactComponentId: z.string(),
+        }),
+    },
+    responses: {
+        200: {
+            description: 'Association status retrieved successfully',
+            content: {
+                'application/json': {
+                    schema: ExistsResponseSchema,
+                },
+            },
+        },
+        ...commonGetErrorResponses,
+    },
+}), async (c) => {
+    const { tenantId, projectId, agentId, artifactComponentId } = c.req.valid('param');
+    const exists = await isArtifactComponentAssociatedWithAgent(dbClient)({
+        scopes: { tenantId, projectId },
+        agentId,
+        artifactComponentId,
+    });
+    return c.json({ exists });
+});
+export default app;

package/dist/routes/agentDataComponents.d.ts

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

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

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

package/dist/routes/agentDataComponents.js

@@ -0,0 +1,225 @@
+import { createRoute, OpenAPIHono } from '@hono/zod-openapi';
+import { z } from 'zod';
+import { associateDataComponentWithAgent, getAgentsUsingDataComponent, getDataComponentsForAgent, getDataComponent, getAgentById, isDataComponentAssociatedWithAgent, removeDataComponentFromAgent, AgentDataComponentApiInsertSchema, AgentDataComponentApiSelectSchema, DataComponentApiSelectSchema, ErrorResponseSchema, SingleResponseSchema, TenantProjectParamsSchema, RemovedResponseSchema, ExistsResponseSchema, } from '@inkeep/agents-core';
+import { commonGetErrorResponses, createApiError } from '@inkeep/agents-core';
+import dbClient from '../data/db/dbClient.js';
+const app = new OpenAPIHono();
+// List data components for a specific agent in a graph
+app.openapi(createRoute({
+    method: 'get',
+    path: '/agent/:agentId',
+    summary: 'Get Data Components for Agent',
+    operationId: 'get-data-components-for-agent',
+    tags: ['CRUD Agent Data Component Relations'],
+    request: {
+        params: TenantProjectParamsSchema.extend({
+            agentId: z.string(),
+        }),
+    },
+    responses: {
+        200: {
+            description: 'Data components retrieved successfully',
+            content: {
+                'application/json': {
+                    schema: z.object({
+                        data: z.array(DataComponentApiSelectSchema),
+                    }),
+                },
+            },
+        },
+        ...commonGetErrorResponses,
+    },
+}), async (c) => {
+    const { tenantId, projectId, agentId } = c.req.valid('param');
+    const dataComponents = await getDataComponentsForAgent(dbClient)({
+        scopes: { tenantId, projectId },
+        agentId,
+    });
+    return c.json({ data: dataComponents });
+});
+// List agent ids using a specific data component
+app.openapi(createRoute({
+    method: 'get',
+    path: '/component/:dataComponentId/agents',
+    summary: 'Get Agents Using Data Component',
+    operationId: 'get-agents-using-data-component',
+    tags: ['CRUD Agent Data Component Relations'],
+    request: {
+        params: TenantProjectParamsSchema.extend({
+            dataComponentId: z.string(),
+        }),
+    },
+    responses: {
+        200: {
+            description: 'Agents retrieved successfully',
+            content: {
+                'application/json': {
+                    schema: z.object({
+                        data: z.array(z.object({
+                            agentId: z.string(),
+                            createdAt: z.string(),
+                        })),
+                    }),
+                },
+            },
+        },
+        ...commonGetErrorResponses,
+    },
+}), async (c) => {
+    const { tenantId, projectId, dataComponentId } = c.req.valid('param');
+    const agents = await getAgentsUsingDataComponent(dbClient)({
+        scopes: { tenantId, projectId },
+        dataComponentId,
+    });
+    return c.json({ data: agents });
+});
+// Create agent data component association
+app.openapi(createRoute({
+    method: 'post',
+    path: '/',
+    summary: 'Associate Data Component with Agent',
+    operationId: 'associate-data-component-with-agent',
+    tags: ['CRUD Agent Data Component Relations'],
+    request: {
+        params: TenantProjectParamsSchema,
+        body: {
+            content: {
+                'application/json': {
+                    schema: AgentDataComponentApiInsertSchema,
+                },
+            },
+        },
+    },
+    responses: {
+        201: {
+            description: 'Agent data component association created successfully',
+            content: {
+                'application/json': {
+                    schema: SingleResponseSchema(AgentDataComponentApiSelectSchema),
+                },
+            },
+        },
+        409: {
+            description: 'Association already exists',
+            content: {
+                'application/json': {
+                    schema: ErrorResponseSchema,
+                },
+            },
+        },
+        ...commonGetErrorResponses,
+    },
+}), async (c) => {
+    const { tenantId, projectId } = c.req.valid('param');
+    const { agentId, dataComponentId } = c.req.valid('json');
+    const [agent, dataComponent] = await Promise.all([
+        getAgentById(dbClient)({ scopes: { tenantId, projectId }, agentId }),
+        getDataComponent(dbClient)({ scopes: { tenantId, projectId }, dataComponentId }),
+    ]);
+    if (!agent) {
+        throw createApiError({
+            code: 'not_found',
+            message: `Agent with id '${agentId}' not found`,
+        });
+    }
+    if (!dataComponent) {
+        throw createApiError({
+            code: 'not_found',
+            message: `Data component with id '${dataComponentId}' not found`,
+        });
+    }
+    // Check if association already exists
+    const exists = await isDataComponentAssociatedWithAgent(dbClient)({
+        scopes: { tenantId, projectId },
+        agentId,
+        dataComponentId,
+    });
+    if (exists) {
+        throw createApiError({
+            code: 'conflict',
+            message: 'Agent data component association already exists',
+        });
+    }
+    const association = await associateDataComponentWithAgent(dbClient)({
+        scopes: { tenantId, projectId },
+        agentId,
+        dataComponentId,
+    });
+    return c.json({ data: association }, 201);
+});
+// Remove agent data component association
+app.openapi(createRoute({
+    method: 'delete',
+    path: '/agent/:agentId/component/:dataComponentId',
+    summary: 'Remove Data Component from Agent',
+    operationId: 'remove-data-component-from-agent',
+    tags: ['CRUD Agent Data Component Relations'],
+    request: {
+        params: TenantProjectParamsSchema.extend({
+            agentId: z.string(),
+            dataComponentId: z.string(),
+        }),
+    },
+    responses: {
+        200: {
+            description: 'Association removed successfully',
+            content: {
+                'application/json': {
+                    schema: RemovedResponseSchema,
+                },
+            },
+        },
+        ...commonGetErrorResponses,
+    },
+}), async (c) => {
+    const { tenantId, projectId, agentId, dataComponentId } = c.req.valid('param');
+    const removed = await removeDataComponentFromAgent(dbClient)({
+        scopes: { tenantId, projectId },
+        agentId,
+        dataComponentId,
+    });
+    if (!removed) {
+        throw createApiError({
+            code: 'not_found',
+            message: 'Agent data component association not found',
+        });
+    }
+    return c.json({
+        message: 'Association removed successfully',
+        removed: true,
+    });
+});
+// Check if data component is associated with agent
+app.openapi(createRoute({
+    method: 'get',
+    path: '/agent/:agentId/component/:dataComponentId/exists',
+    summary: 'Check if Data Component is Associated with Agent',
+    operationId: 'check-data-component-agent-association',
+    tags: ['CRUD Agent Data Component Relations'],
+    request: {
+        params: TenantProjectParamsSchema.extend({
+            agentId: z.string(),
+            dataComponentId: z.string(),
+        }),
+    },
+    responses: {
+        200: {
+            description: 'Association status retrieved successfully',
+            content: {
+                'application/json': {
+                    schema: ExistsResponseSchema,
+                },
+            },
+        },
+        ...commonGetErrorResponses,
+    },
+}), async (c) => {
+    const { tenantId, projectId, agentId, dataComponentId } = c.req.valid('param');
+    const exists = await isDataComponentAssociatedWithAgent(dbClient)({
+        scopes: { tenantId, projectId },
+        agentId,
+        dataComponentId,
+    });
+    return c.json({ exists });
+});
+export default app;

package/dist/routes/agentGraph.d.ts

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

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

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