@inkeep/agents-manage-api 0.1.1 → 0.1.6

package/dist/routes/agentToolRelations.js

@@ -1,342 +0,0 @@
-import { createRoute, OpenAPIHono } from '@hono/zod-openapi';
-import { z } from 'zod';
-import { commonGetErrorResponses, createApiError } from '@inkeep/agents-core';
-import { AgentToolRelationApiInsertSchema, AgentToolRelationApiSelectSchema, AgentToolRelationApiUpdateSchema, ErrorResponseSchema, IdParamsSchema, ListResponseSchema, PaginationQueryParamsSchema, SingleResponseSchema, TenantProjectParamsSchema, getAgentToolRelationById, getAgentToolRelationByAgent, getAgentToolRelationByTool, listAgentToolRelations, getToolsForAgent, getAgentsForTool, createAgentToolRelation, updateAgentToolRelation, deleteAgentToolRelation, } from '@inkeep/agents-core';
-import dbClient from '../data/db/dbClient.js';
-const app = new OpenAPIHono();
-// List agent tool relations
-app.openapi(createRoute({
-    method: 'get',
-    path: '/',
-    summary: 'List Agent Tool Relations',
-    operationId: 'list-agent-tool-relations',
-    tags: ['CRUD Agent Tool Relations'],
-    request: {
-        params: TenantProjectParamsSchema,
-        query: PaginationQueryParamsSchema.extend({
-            agentId: z.string().optional(),
-            toolId: z.string().optional(),
-        }),
-    },
-    responses: {
-        200: {
-            description: 'List of agent tool relations retrieved successfully',
-            content: {
-                'application/json': {
-                    schema: ListResponseSchema(AgentToolRelationApiSelectSchema),
-                },
-            },
-        },
-        ...commonGetErrorResponses,
-    },
-}), async (c) => {
-    const { tenantId, projectId } = c.req.valid('param');
-    const { page, limit, agentId, toolId } = c.req.valid('query');
-    let result;
-    // Filter by agent if provided
-    if (agentId) {
-        const dbResult = await getAgentToolRelationByAgent(dbClient)({
-            scopes: { tenantId, projectId },
-            agentId,
-            pagination: { page, limit },
-        });
-        result = {
-            data: dbResult.data,
-            pagination: dbResult.pagination,
-        };
-    }
-    // Filter by tool if provided
-    else if (toolId) {
-        const dbResult = await getAgentToolRelationByTool(dbClient)({
-            scopes: { tenantId, projectId },
-            toolId,
-            pagination: { page, limit },
-        });
-        result = {
-            data: dbResult.data,
-            pagination: dbResult.pagination,
-        };
-    }
-    // Default: get all agent tool relations
-    else {
-        const dbResult = await listAgentToolRelations(dbClient)({
-            scopes: { tenantId, projectId },
-            pagination: { page, limit },
-        });
-        result = {
-            data: dbResult.data,
-            pagination: dbResult.pagination,
-        };
-    }
-    return c.json(result);
-});
-// Get agent tool relation by ID
-app.openapi(createRoute({
-    method: 'get',
-    path: '/{id}',
-    summary: 'Get Agent Tool Relation',
-    operationId: 'get-agent-tool-relation',
-    tags: ['CRUD Agent Tool Relations'],
-    request: {
-        params: TenantProjectParamsSchema.merge(IdParamsSchema),
-    },
-    responses: {
-        200: {
-            description: 'Agent tool relation found',
-            content: {
-                'application/json': {
-                    schema: SingleResponseSchema(AgentToolRelationApiSelectSchema),
-                },
-            },
-        },
-        ...commonGetErrorResponses,
-    },
-}), async (c) => {
-    const { tenantId, projectId, id } = c.req.valid('param');
-    const agentToolRelation = await getAgentToolRelationById(dbClient)({
-        scopes: { tenantId, projectId },
-        relationId: id,
-    });
-    if (!agentToolRelation) {
-        throw createApiError({
-            code: 'not_found',
-            message: 'Agent tool relation not found',
-        });
-    }
-    return c.json({ data: agentToolRelation });
-});
-// Get tools for a specific agent (with tool details)
-app.openapi(createRoute({
-    method: 'get',
-    path: '/agent/{agentId}/tools',
-    summary: 'Get Tools for Agent',
-    operationId: 'get-tools-for-agent',
-    tags: ['CRUD Agent Tool Relations'],
-    request: {
-        params: TenantProjectParamsSchema.extend({
-            agentId: z.string(),
-        }),
-        query: PaginationQueryParamsSchema,
-    },
-    responses: {
-        200: {
-            description: 'Tools for agent retrieved successfully',
-            content: {
-                'application/json': {
-                    schema: ListResponseSchema(AgentToolRelationApiSelectSchema),
-                },
-            },
-        },
-        ...commonGetErrorResponses,
-    },
-}), async (c) => {
-    const { tenantId, projectId, agentId } = c.req.valid('param');
-    const { page, limit } = c.req.valid('query');
-    const dbResult = await getToolsForAgent(dbClient)({
-        scopes: { tenantId, projectId },
-        agentId,
-        pagination: { page, limit },
-    });
-    const result = {
-        data: dbResult.data,
-        pagination: dbResult.pagination,
-    };
-    return c.json(result);
-});
-// Get agents for a specific tool (with agent details)
-app.openapi(createRoute({
-    method: 'get',
-    path: '/tool/{toolId}/agents',
-    summary: 'Get Agents for Tool',
-    operationId: 'get-agents-for-tool',
-    tags: ['CRUD Agent Tool Relations'],
-    request: {
-        params: TenantProjectParamsSchema.extend({
-            toolId: z.string(),
-        }),
-        query: PaginationQueryParamsSchema,
-    },
-    responses: {
-        200: {
-            description: 'Agents for tool retrieved successfully',
-            content: {
-                'application/json': {
-                    schema: ListResponseSchema(AgentToolRelationApiSelectSchema),
-                },
-            },
-        },
-        ...commonGetErrorResponses,
-    },
-}), async (c) => {
-    const { tenantId, projectId, toolId } = c.req.valid('param');
-    const { page, limit } = c.req.valid('query');
-    const dbResult = await getAgentsForTool(dbClient)({
-        scopes: { tenantId, projectId },
-        toolId,
-        pagination: { page, limit },
-    });
-    const result = {
-        data: dbResult.data,
-        pagination: dbResult.pagination,
-    };
-    return c.json(result);
-});
-// Create agent tool relation
-app.openapi(createRoute({
-    method: 'post',
-    path: '/',
-    summary: 'Create Agent Tool Relation',
-    operationId: 'create-agent-tool-relation',
-    tags: ['CRUD Agent Tool Relations'],
-    request: {
-        params: TenantProjectParamsSchema,
-        body: {
-            content: {
-                'application/json': {
-                    schema: AgentToolRelationApiInsertSchema,
-                },
-            },
-        },
-    },
-    responses: {
-        201: {
-            description: 'Agent tool relation created successfully',
-            content: {
-                'application/json': {
-                    schema: SingleResponseSchema(AgentToolRelationApiSelectSchema),
-                },
-            },
-        },
-        ...commonGetErrorResponses,
-    },
-}), async (c) => {
-    const { tenantId, projectId } = c.req.valid('param');
-    const body = c.req.valid('json');
-    // Check if relation already exists (prevent duplicates)
-    const existingRelations = await listAgentToolRelations(dbClient)({
-        scopes: { tenantId, projectId },
-        pagination: { limit: 1000 },
-    });
-    const isDuplicate = existingRelations.data.some((relation) => {
-        const typedRelation = relation;
-        return typedRelation.agentId === body.agentId && typedRelation.toolId === body.toolId;
-    });
-    if (isDuplicate) {
-        throw createApiError({
-            code: 'unprocessable_entity',
-            message: 'Agent tool relation already exists',
-        });
-    }
-    try {
-        const agentToolRelation = await createAgentToolRelation(dbClient)({
-            scopes: { tenantId, projectId },
-            data: body,
-        });
-        return c.json({ data: agentToolRelation }, 201);
-    }
-    catch (error) {
-        // Handle foreign key constraint violations
-        if (error instanceof Error && (error.message.includes('FOREIGN KEY constraint failed') ||
-            error.message.includes('foreign key constraint') ||
-            error.message.includes('SQLITE_CONSTRAINT_FOREIGNKEY') ||
-            error.code === 'SQLITE_CONSTRAINT_FOREIGNKEY' ||
-            error?.cause?.code === 'SQLITE_CONSTRAINT_FOREIGNKEY')) {
-            throw createApiError({
-                code: 'bad_request',
-                message: 'Invalid agent ID or tool ID - referenced entity does not exist',
-            });
-        }
-        throw error;
-    }
-});
-// Update agent tool relation
-app.openapi(createRoute({
-    method: 'put',
-    path: '/{id}',
-    summary: 'Update Agent Tool Relation',
-    operationId: 'update-agent-tool-relation',
-    tags: ['CRUD Agent Tool Relations'],
-    request: {
-        params: TenantProjectParamsSchema.merge(IdParamsSchema),
-        body: {
-            content: {
-                'application/json': {
-                    schema: AgentToolRelationApiUpdateSchema,
-                },
-            },
-        },
-    },
-    responses: {
-        200: {
-            description: 'Agent tool relation updated successfully',
-            content: {
-                'application/json': {
-                    schema: SingleResponseSchema(AgentToolRelationApiSelectSchema),
-                },
-            },
-        },
-        ...commonGetErrorResponses,
-    },
-}), async (c) => {
-    const { tenantId, projectId, id } = c.req.valid('param');
-    console.log('id', id);
-    const body = await c.req.valid('json');
-    // Check if there are any fields to update
-    if (Object.keys(body).length === 0) {
-        throw createApiError({
-            code: 'bad_request',
-            message: 'No fields to update',
-        });
-    }
-    console.log('body', body);
-    const updatedAgentToolRelation = await updateAgentToolRelation(dbClient)({
-        scopes: { tenantId, projectId },
-        relationId: id,
-        data: body,
-    });
-    if (!updatedAgentToolRelation) {
-        throw createApiError({
-            code: 'not_found',
-            message: 'Agent tool relation not found',
-        });
-    }
-    return c.json({ data: updatedAgentToolRelation });
-});
-// Delete agent tool relation
-app.openapi(createRoute({
-    method: 'delete',
-    path: '/{id}',
-    summary: 'Delete Agent Tool Relation',
-    operationId: 'delete-agent-tool-relation',
-    tags: ['CRUD Agent Tool Relations'],
-    request: {
-        params: TenantProjectParamsSchema.merge(IdParamsSchema),
-    },
-    responses: {
-        204: {
-            description: 'Agent tool relation deleted successfully',
-        },
-        404: {
-            description: 'Agent tool relation not found',
-            content: {
-                'application/json': {
-                    schema: ErrorResponseSchema,
-                },
-            },
-        },
-    },
-}), async (c) => {
-    const { tenantId, projectId, id } = c.req.valid('param');
-    const deleted = await deleteAgentToolRelation(dbClient)({
-        scopes: { tenantId, projectId },
-        relationId: id,
-    });
-    if (!deleted) {
-        throw createApiError({
-            code: 'not_found',
-            message: 'Agent tool relation not found',
-        });
-    }
-    return c.body(null, 204);
-});
-export default app;

package/dist/routes/agents.d.ts

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

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

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

package/dist/routes/agents.js

@@ -1,213 +0,0 @@
-import { createRoute, OpenAPIHono } from '@hono/zod-openapi';
-import { nanoid } from 'nanoid';
-import { commonGetErrorResponses, createApiError } from '@inkeep/agents-core';
-import { listAgentsPaginated, getAgentById, createAgent, updateAgent, deleteAgent, AgentApiInsertSchema, AgentApiSelectSchema, AgentApiUpdateSchema, ErrorResponseSchema, ListResponseSchema, PaginationQueryParamsSchema, SingleResponseSchema, TenantProjectIdParamsSchema, TenantProjectParamsSchema, } from '@inkeep/agents-core';
-import dbClient from '../data/db/dbClient.js';
-const app = new OpenAPIHono();
-app.openapi(createRoute({
-    method: 'get',
-    path: '/',
-    summary: 'List Agents',
-    operationId: 'list-agents',
-    tags: ['CRUD Agent'],
-    request: {
-        params: TenantProjectParamsSchema,
-        query: PaginationQueryParamsSchema,
-    },
-    responses: {
-        200: {
-            description: 'List of agents retrieved successfully',
-            content: {
-                'application/json': {
-                    schema: ListResponseSchema(AgentApiSelectSchema),
-                },
-            },
-        },
-        ...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 result = await listAgentsPaginated(dbClient)({
-        scopes: { tenantId, projectId },
-        pagination: { page, limit },
-    });
-    // Add type field to all agents in the response
-    const dataWithType = {
-        ...result,
-        data: result.data.map((agent) => ({
-            ...agent,
-            type: 'internal',
-        })),
-    };
-    return c.json(dataWithType);
-});
-app.openapi(createRoute({
-    method: 'get',
-    path: '/{id}',
-    summary: 'Get Agent',
-    operationId: 'get-agent-by-id',
-    tags: ['CRUD Agent'],
-    request: {
-        params: TenantProjectIdParamsSchema,
-    },
-    responses: {
-        200: {
-            description: 'Agent found',
-            content: {
-                'application/json': {
-                    schema: SingleResponseSchema(AgentApiSelectSchema),
-                },
-            },
-        },
-        ...commonGetErrorResponses,
-    },
-}), async (c) => {
-    const { tenantId, projectId, id } = c.req.valid('param');
-    const agent = await getAgentById(dbClient)({
-        scopes: { tenantId, projectId },
-        agentId: id,
-    });
-    if (!agent) {
-        throw createApiError({
-            code: 'not_found',
-            message: 'Agent not found',
-        });
-    }
-    // Add type field to the agent response
-    const agentWithType = {
-        ...agent,
-        type: 'internal',
-    };
-    return c.json({ data: agentWithType });
-});
-app.openapi(createRoute({
-    method: 'post',
-    path: '/',
-    summary: 'Create Agent',
-    operationId: 'create-agent',
-    tags: ['CRUD Agent'],
-    request: {
-        params: TenantProjectParamsSchema,
-        body: {
-            content: {
-                'application/json': {
-                    schema: AgentApiInsertSchema,
-                },
-            },
-        },
-    },
-    responses: {
-        201: {
-            description: 'Agent created successfully',
-            content: {
-                'application/json': {
-                    schema: SingleResponseSchema(AgentApiSelectSchema),
-                },
-            },
-        },
-        ...commonGetErrorResponses,
-    },
-}), async (c) => {
-    const { tenantId, projectId } = c.req.valid('param');
-    const body = c.req.valid('json');
-    const agentId = body.id ? String(body.id) : nanoid();
-    const agent = await createAgent(dbClient)({
-        ...body,
-        id: agentId,
-        tenantId,
-        projectId,
-    });
-    // Add type field to the agent response
-    const agentWithType = {
-        ...agent,
-        type: 'internal',
-    };
-    return c.json({ data: agentWithType }, 201);
-});
-app.openapi(createRoute({
-    method: 'put',
-    path: '/{id}',
-    summary: 'Update Agent',
-    operationId: 'update-agent',
-    tags: ['CRUD Agent'],
-    request: {
-        params: TenantProjectIdParamsSchema,
-        body: {
-            content: {
-                'application/json': {
-                    schema: AgentApiUpdateSchema,
-                },
-            },
-        },
-    },
-    responses: {
-        200: {
-            description: 'Agent updated successfully',
-            content: {
-                'application/json': {
-                    schema: SingleResponseSchema(AgentApiSelectSchema),
-                },
-            },
-        },
-        ...commonGetErrorResponses,
-    },
-}), async (c) => {
-    const { tenantId, projectId, id } = c.req.valid('param');
-    const body = c.req.valid('json');
-    const updatedAgent = await updateAgent(dbClient)({
-        scopes: { tenantId, projectId },
-        agentId: id,
-        data: body,
-    });
-    if (!updatedAgent) {
-        throw createApiError({
-            code: 'not_found',
-            message: 'Agent not found',
-        });
-    }
-    // Add type field to the agent response
-    const agentWithType = {
-        ...updatedAgent,
-        type: 'internal',
-    };
-    return c.json({ data: agentWithType });
-});
-app.openapi(createRoute({
-    method: 'delete',
-    path: '/{id}',
-    summary: 'Delete Agent',
-    operationId: 'delete-agent',
-    tags: ['CRUD Agent'],
-    request: {
-        params: TenantProjectIdParamsSchema,
-    },
-    responses: {
-        204: {
-            description: 'Agent deleted successfully',
-        },
-        404: {
-            description: 'Agent not found',
-            content: {
-                'application/json': {
-                    schema: ErrorResponseSchema,
-                },
-            },
-        },
-    },
-}), async (c) => {
-    const { tenantId, projectId, id } = c.req.valid('param');
-    const deleted = await deleteAgent(dbClient)({
-        scopes: { tenantId, projectId },
-        agentId: id,
-    });
-    if (!deleted) {
-        throw createApiError({
-            code: 'not_found',
-            message: 'Agent not found',
-        });
-    }
-    return c.body(null, 204);
-});
-export default app;

package/dist/routes/apiKeys.d.ts

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

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

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