@inkeep/agents-manage-api 0.1.0

package/dist/routes/agentGraph.js

@@ -0,0 +1,289 @@
+// @ts-nocheck
+import { createRoute, OpenAPIHono } from '@hono/zod-openapi';
+import { nanoid } from 'nanoid';
+import { z } from 'zod';
+import { listAgentGraphs } from '@inkeep/agents-core';
+import { commonGetErrorResponses, createApiError } from '@inkeep/agents-core';
+import { createAgentGraph, deleteAgentGraph, getAgentGraph, getFullGraphDefinition, getGraphAgentInfos, updateAgentGraph, AgentGraphApiInsertSchema, AgentGraphApiSelectSchema, AgentGraphApiUpdateSchema, ErrorResponseSchema, FullGraphDefinitionSchema, IdParamsSchema, ListResponseSchema, PaginationQueryParamsSchema, SingleResponseSchema, TenantProjectParamsSchema, } from '@inkeep/agents-core';
+import dbClient from '../data/db/dbClient.js';
+const app = new OpenAPIHono();
+// List agent graphs
+app.openapi(createRoute({
+    method: 'get',
+    path: '/',
+    summary: 'List Agent Graphs',
+    operationId: 'list-agent-graphs',
+    tags: ['CRUD Agent Graph'],
+    request: {
+        params: TenantProjectParamsSchema,
+        query: PaginationQueryParamsSchema,
+    },
+    responses: {
+        200: {
+            description: 'List of agent graphs retrieved successfully',
+            content: {
+                'application/json': {
+                    schema: ListResponseSchema(AgentGraphApiSelectSchema),
+                },
+            },
+        },
+        ...commonGetErrorResponses,
+    },
+}), async (c) => {
+    const { tenantId, projectId } = c.req.valid('param');
+    const page = Number(c.req.query('page')) || 1;
+    const limit = Math.min(Number(c.req.query('limit')) || 10, 100);
+    const graphs = await listAgentGraphs(dbClient)({ scopes: { tenantId, projectId } });
+    return c.json({
+        data: graphs,
+        pagination: {
+            page,
+            limit,
+            total: graphs.length,
+            pages: Math.ceil(graphs.length / limit),
+        },
+    });
+});
+// Get agent graph by ID
+app.openapi(createRoute({
+    method: 'get',
+    path: '/{id}',
+    summary: 'Get Agent Graph',
+    operationId: 'get-agent-graph',
+    tags: ['CRUD Agent Graph'],
+    request: {
+        params: TenantProjectParamsSchema.merge(IdParamsSchema),
+    },
+    responses: {
+        200: {
+            description: 'Agent graph found',
+            content: {
+                'application/json': {
+                    schema: SingleResponseSchema(AgentGraphApiSelectSchema),
+                },
+            },
+        },
+        ...commonGetErrorResponses,
+    },
+}), async (c) => {
+    const { tenantId, projectId, id } = c.req.valid('param');
+    const graph = await getAgentGraph(dbClient)({
+        scopes: { tenantId, projectId },
+        graphId: id,
+    });
+    if (!graph) {
+        throw createApiError({
+            code: 'not_found',
+            message: 'Agent graph not found',
+        });
+    }
+    return c.json({ data: graph });
+});
+// Get related agent infos for a specific agent within a graph
+app.openapi(createRoute({
+    method: 'get',
+    path: '/{graphId}/agents/{agentId}/related',
+    summary: 'Get Related Agent Infos',
+    operationId: 'get-related-agent-infos',
+    tags: ['CRUD Agent Graph'],
+    request: {
+        params: TenantProjectParamsSchema.extend({
+            graphId: z.string(),
+            agentId: z.string(),
+        }),
+    },
+    responses: {
+        200: {
+            description: 'Related agent infos retrieved successfully',
+            content: {
+                'application/json': {
+                    schema: ListResponseSchema(z.object({
+                        id: z.string(),
+                        name: z.string(),
+                        description: z.string(),
+                    })),
+                },
+            },
+        },
+        ...commonGetErrorResponses,
+    },
+}), async (c) => {
+    const { tenantId, projectId, graphId, agentId } = c.req.valid('param');
+    const relatedAgents = await getGraphAgentInfos(dbClient)({
+        scopes: { tenantId, projectId },
+        graphId,
+        agentId,
+    });
+    return c.json({
+        data: relatedAgents,
+        pagination: {
+            page: 1,
+            limit: relatedAgents.length,
+            total: relatedAgents.length,
+            pages: 1,
+        },
+    });
+});
+// Get full graph definition
+app.openapi(createRoute({
+    method: 'get',
+    path: '/{graphId}/full',
+    summary: 'Get Full Graph Definition',
+    operationId: 'get-full-graph-definition',
+    tags: ['CRUD Agent Graph'],
+    request: {
+        params: TenantProjectParamsSchema.extend({
+            graphId: z.string(),
+        }),
+    },
+    responses: {
+        200: {
+            description: 'Full graph definition retrieved successfully',
+            content: {
+                'application/json': {
+                    schema: SingleResponseSchema(FullGraphDefinitionSchema),
+                },
+            },
+        },
+        ...commonGetErrorResponses,
+    },
+}), async (c) => {
+    const { tenantId, projectId, graphId } = c.req.valid('param');
+    const fullGraph = await getFullGraphDefinition(dbClient)({
+        scopes: { tenantId, projectId },
+        graphId,
+    });
+    if (!fullGraph) {
+        throw createApiError({
+            code: 'not_found',
+            message: 'Agent graph not found',
+        });
+    }
+    return c.json({ data: fullGraph });
+});
+// Create agent graph
+app.openapi(createRoute({
+    method: 'post',
+    path: '/',
+    summary: 'Create Agent Graph',
+    operationId: 'create-agent-graph',
+    tags: ['CRUD Agent Graph'],
+    request: {
+        params: TenantProjectParamsSchema,
+        body: {
+            content: {
+                'application/json': {
+                    schema: AgentGraphApiInsertSchema,
+                },
+            },
+        },
+    },
+    responses: {
+        201: {
+            description: 'Agent graph created successfully',
+            content: {
+                'application/json': {
+                    schema: SingleResponseSchema(AgentGraphApiSelectSchema),
+                },
+            },
+        },
+        ...commonGetErrorResponses,
+    },
+}), async (c) => {
+    const { tenantId, projectId } = c.req.valid('param');
+    const validatedBody = c.req.valid('json');
+    const graph = await createAgentGraph(dbClient)({
+        tenantId,
+        projectId,
+        id: validatedBody.id || nanoid(),
+        name: validatedBody.name,
+        defaultAgentId: validatedBody.defaultAgentId,
+        contextConfigId: validatedBody.contextConfigId ?? undefined,
+    });
+    return c.json({ data: graph }, 201);
+});
+// Update agent graph
+app.openapi(createRoute({
+    method: 'put',
+    path: '/{id}',
+    summary: 'Update Agent Graph',
+    operationId: 'update-agent-graph',
+    tags: ['CRUD Agent Graph'],
+    request: {
+        params: TenantProjectParamsSchema.merge(IdParamsSchema),
+        body: {
+            content: {
+                'application/json': {
+                    schema: AgentGraphApiUpdateSchema,
+                },
+            },
+        },
+    },
+    responses: {
+        200: {
+            description: 'Agent graph updated successfully',
+            content: {
+                'application/json': {
+                    schema: SingleResponseSchema(AgentGraphApiSelectSchema),
+                },
+            },
+        },
+        ...commonGetErrorResponses,
+    },
+}), async (c) => {
+    const { tenantId, projectId, id } = c.req.valid('param');
+    const validatedBody = c.req.valid('json');
+    const updatedGraph = await updateAgentGraph(dbClient)({
+        scopes: { tenantId, projectId },
+        graphId: id,
+        data: {
+            defaultAgentId: validatedBody.defaultAgentId,
+            contextConfigId: validatedBody.contextConfigId ?? undefined,
+        },
+    });
+    if (!updatedGraph) {
+        throw createApiError({
+            code: 'not_found',
+            message: 'Agent graph not found',
+        });
+    }
+    return c.json({ data: updatedGraph });
+});
+// Delete agent graph
+app.openapi(createRoute({
+    method: 'delete',
+    path: '/{id}',
+    summary: 'Delete Agent Graph',
+    operationId: 'delete-agent-graph',
+    tags: ['CRUD Agent Graph'],
+    request: {
+        params: TenantProjectParamsSchema.merge(IdParamsSchema),
+    },
+    responses: {
+        204: {
+            description: 'Agent graph deleted successfully',
+        },
+        404: {
+            description: 'Agent graph not found',
+            content: {
+                'application/json': {
+                    schema: ErrorResponseSchema,
+                },
+            },
+        },
+    },
+}), async (c) => {
+    const { tenantId, projectId, id } = c.req.valid('param');
+    const deleted = await deleteAgentGraph(dbClient)({
+        scopes: { tenantId, projectId },
+        graphId: id,
+    });
+    if (!deleted) {
+        throw createApiError({
+            code: 'not_found',
+            message: 'Agent graph not found',
+        });
+    }
+    return c.body(null, 204);
+});
+export default app;

package/dist/routes/agentRelations.d.ts

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

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

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

package/dist/routes/agentRelations.js

@@ -0,0 +1,290 @@
+import { createRoute, OpenAPIHono } from '@hono/zod-openapi';
+import { commonGetErrorResponses, createApiError } from '@inkeep/agents-core';
+import { ErrorResponseSchema, IdParamsSchema, ListResponseSchema, PaginationQueryParamsSchema, SingleResponseSchema, TenantProjectParamsSchema, AgentRelationQuerySchema, AgentRelationApiInsertSchema, AgentRelationApiUpdateSchema, AgentRelationApiSelectSchema, getAgentRelationsBySource, getAgentRelationsByTarget, getExternalAgentRelations, listAgentRelations, getAgentRelationById, validateExternalAgent, validateInternalAgent, createAgentRelation, updateAgentRelation, deleteAgentRelation, } from '@inkeep/agents-core';
+import dbClient from '../data/db/dbClient.js';
+import { nanoid } from 'nanoid';
+const app = new OpenAPIHono();
+// List agent relations
+app.openapi(createRoute({
+    method: 'get',
+    path: '/',
+    summary: 'List Agent Relations',
+    operationId: 'list-agent-relations',
+    tags: ['CRUD Agent Relations'],
+    request: {
+        params: TenantProjectParamsSchema,
+        query: PaginationQueryParamsSchema.merge(AgentRelationQuerySchema),
+    },
+    responses: {
+        200: {
+            description: 'List of agent relations retrieved successfully',
+            content: {
+                'application/json': {
+                    schema: ListResponseSchema(AgentRelationApiSelectSchema),
+                },
+            },
+        },
+        ...commonGetErrorResponses,
+    },
+}), async (c) => {
+    const { tenantId, projectId } = c.req.valid('param');
+    const { page = 1, limit = 10, sourceAgentId, targetAgentId, externalAgentId, } = c.req.valid('query');
+    const pageNum = Number(page);
+    const limitNum = Math.min(Number(limit), 100);
+    try {
+        let result;
+        if (sourceAgentId) {
+            const rawResult = await getAgentRelationsBySource(dbClient)({
+                scopes: { tenantId, projectId },
+                sourceAgentId,
+                pagination: { page: pageNum, limit: limitNum },
+            });
+            result = { ...rawResult, data: rawResult.data };
+        }
+        else if (targetAgentId) {
+            const rawResult = await getAgentRelationsByTarget(dbClient)({
+                scopes: { tenantId, projectId },
+                targetAgentId,
+                pagination: { page: pageNum, limit: limitNum },
+            });
+            result = { ...rawResult, data: rawResult.data };
+        }
+        else if (externalAgentId) {
+            const rawResult = await getExternalAgentRelations(dbClient)({
+                scopes: { tenantId, projectId },
+                externalAgentId,
+                pagination: { page: pageNum, limit: limitNum },
+            });
+            result = { ...rawResult, data: rawResult.data };
+        }
+        else {
+            const rawResult = await listAgentRelations(dbClient)({
+                scopes: { tenantId, projectId },
+                pagination: { page: pageNum, limit: limitNum },
+            });
+            result = { ...rawResult, data: rawResult.data };
+        }
+        return c.json(result);
+    }
+    catch (error) {
+        throw createApiError({
+            code: 'internal_server_error',
+            message: 'Failed to retrieve agent relations',
+        });
+    }
+});
+// Get agent relation by ID
+app.openapi(createRoute({
+    method: 'get',
+    path: '/{id}',
+    summary: 'Get Agent Relation',
+    operationId: 'get-agent-relation-by-id',
+    tags: ['CRUD Agent Relations'],
+    request: {
+        params: TenantProjectParamsSchema.merge(IdParamsSchema),
+    },
+    responses: {
+        200: {
+            description: 'Agent relation found',
+            content: {
+                'application/json': {
+                    schema: SingleResponseSchema(AgentRelationApiSelectSchema),
+                },
+            },
+        },
+        ...commonGetErrorResponses,
+    },
+}), async (c) => {
+    const { tenantId, projectId, id } = c.req.valid('param');
+    const agentRelation = (await getAgentRelationById(dbClient)({
+        scopes: { tenantId, projectId },
+        relationId: id,
+    }));
+    if (!agentRelation) {
+        throw createApiError({
+            code: 'not_found',
+            message: 'Agent relation not found',
+        });
+    }
+    return c.json({ data: agentRelation });
+});
+// Create agent relation
+app.openapi(createRoute({
+    method: 'post',
+    path: '/',
+    summary: 'Create Agent Relation',
+    operationId: 'create-agent-relation',
+    tags: ['CRUD Agent Relations'],
+    request: {
+        params: TenantProjectParamsSchema,
+        body: {
+            content: {
+                'application/json': {
+                    schema: AgentRelationApiInsertSchema,
+                },
+            },
+        },
+    },
+    responses: {
+        201: {
+            description: 'Agent relation created successfully',
+            content: {
+                'application/json': {
+                    schema: SingleResponseSchema(AgentRelationApiSelectSchema),
+                },
+            },
+        },
+        ...commonGetErrorResponses,
+    },
+}), async (c) => {
+    const { tenantId, projectId } = c.req.valid('param');
+    const body = await c.req.valid('json');
+    // Determine if this is an external agent relationship
+    const isExternalAgent = body.externalAgentId != null;
+    // Validate that the target agent exists in the appropriate table
+    if (isExternalAgent && body.externalAgentId) {
+        // Check if external agent exists
+        const externalAgentExists = await validateExternalAgent(dbClient)({
+            scopes: { tenantId, projectId },
+            agentId: body.externalAgentId,
+        });
+        if (!externalAgentExists) {
+            throw createApiError({
+                code: 'bad_request',
+                message: `External agent with ID ${body.externalAgentId} not found`,
+            });
+        }
+    }
+    if (!isExternalAgent && body.targetAgentId) {
+        // Check if internal agent exists
+        const internalAgentExists = await validateInternalAgent(dbClient)({
+            scopes: { tenantId, projectId },
+            agentId: body.targetAgentId,
+        });
+        if (!internalAgentExists) {
+            throw createApiError({
+                code: 'bad_request',
+                message: `Internal agent with ID ${body.targetAgentId} not found`,
+            });
+        }
+    }
+    // Check if relation already exists (prevent duplicates)
+    const existingRelations = await listAgentRelations(dbClient)({
+        scopes: { tenantId, projectId },
+        pagination: { page: 1, limit: 1000 },
+    });
+    const isDuplicate = existingRelations.data.some((relation) => {
+        if (relation.graphId !== body.graphId || relation.sourceAgentId !== body.sourceAgentId) {
+            return false;
+        }
+        // Check for duplicate based on relationship type
+        if (isExternalAgent) {
+            return relation.externalAgentId === body.externalAgentId;
+        }
+        return relation.targetAgentId === body.targetAgentId;
+    });
+    if (isDuplicate) {
+        const agentType = isExternalAgent ? 'external' : 'internal';
+        throw createApiError({
+            code: 'unprocessable_entity',
+            message: `A relation between these agents (${agentType}) in this graph already exists`,
+        });
+    }
+    // Create the relation with the correct data structure
+    const relationData = {
+        graphId: body.graphId,
+        tenantId,
+        id: nanoid(),
+        projectId,
+        sourceAgentId: body.sourceAgentId,
+        targetAgentId: isExternalAgent ? undefined : body.targetAgentId,
+        externalAgentId: isExternalAgent ? body.externalAgentId : undefined,
+        relationType: body.relationType,
+    };
+    const agentRelation = await createAgentRelation(dbClient)({
+        ...relationData,
+    });
+    return c.json({ data: agentRelation }, 201);
+});
+// Update agent relation
+app.openapi(createRoute({
+    method: 'put',
+    path: '/{id}',
+    summary: 'Update Agent Relation',
+    operationId: 'update-agent-relation',
+    tags: ['CRUD Agent Relations'],
+    request: {
+        params: TenantProjectParamsSchema.merge(IdParamsSchema),
+        body: {
+            content: {
+                'application/json': {
+                    schema: AgentRelationApiUpdateSchema,
+                },
+            },
+        },
+    },
+    responses: {
+        200: {
+            description: 'Agent relation updated successfully',
+            content: {
+                'application/json': {
+                    schema: SingleResponseSchema(AgentRelationApiSelectSchema),
+                },
+            },
+        },
+        ...commonGetErrorResponses,
+    },
+}), async (c) => {
+    const { tenantId, projectId, id } = c.req.valid('param');
+    const body = await c.req.valid('json');
+    const updatedAgentRelation = await updateAgentRelation(dbClient)({
+        scopes: { tenantId, projectId },
+        relationId: id,
+        data: body,
+    });
+    if (!updatedAgentRelation) {
+        throw createApiError({
+            code: 'not_found',
+            message: 'Agent relation not found',
+        });
+    }
+    return c.json({ data: updatedAgentRelation });
+});
+// Delete agent relation
+app.openapi(createRoute({
+    method: 'delete',
+    path: '/{id}',
+    summary: 'Delete Agent Relation',
+    operationId: 'delete-agent-relation',
+    tags: ['CRUD Agent Relations'],
+    request: {
+        params: TenantProjectParamsSchema.merge(IdParamsSchema),
+    },
+    responses: {
+        204: {
+            description: 'Agent relation deleted successfully',
+        },
+        404: {
+            description: 'Agent relation not found',
+            content: {
+                'application/json': {
+                    schema: ErrorResponseSchema,
+                },
+            },
+        },
+    },
+}), async (c) => {
+    const { tenantId, projectId, id } = c.req.valid('param');
+    const deleted = await deleteAgentRelation(dbClient)({
+        scopes: { tenantId, projectId },
+        relationId: id,
+    });
+    if (!deleted) {
+        throw createApiError({
+            code: 'not_found',
+            message: 'Agent relation not found',
+        });
+    }
+    return c.body(null, 204);
+});
+export default app;

package/dist/routes/agentToolRelations.d.ts

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

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

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