@inkeep/agents-manage-api 0.1.1 → 0.1.6

package/dist/routes/agentArtifactComponents.js

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

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

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

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

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

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