@superinterface/server 1.0.24 → 1.0.26

package/dist/app/api/assistants/[assistantId]/mcp-servers/[mcpServerId]/buildRoute.js

@@ -0,0 +1,167 @@
+import { headers } from 'next/headers';
+import { ApiKeyType, TransportType } from '@prisma/client';
+import { NextResponse } from 'next/server';
+import { cacheHeaders } from '../../../../../../lib/cache/cacheHeaders';
+import { getApiKey } from '../../../../../../lib/apiKeys/getApiKey';
+import { validate } from 'uuid';
+import { serializeApiMcpServer } from '../../../../../../lib/mcpServers/serializeApiMcpServer';
+import { mcpServerSchema } from '../../../../../../lib/mcpServers/mcpServerSchema';
+const validateIds = ({ assistantId, mcpServerId, }) => {
+    if (!validate(assistantId)) {
+        return NextResponse.json({ error: 'Invalid assistant id' }, { status: 400 });
+    }
+    if (!validate(mcpServerId)) {
+        return NextResponse.json({ error: 'Invalid MCP server id' }, { status: 400 });
+    }
+    return null;
+};
+export const buildGET = ({ prisma }) => async (_request, props) => {
+    const { assistantId, mcpServerId } = await props.params;
+    const headersList = await headers();
+    const authorization = headersList.get('authorization');
+    if (!authorization) {
+        return NextResponse.json({ error: 'No authorization header found' }, { status: 400 });
+    }
+    const privateApiKey = await getApiKey({
+        type: ApiKeyType.PRIVATE,
+        authorization,
+        prisma,
+    });
+    if (!privateApiKey) {
+        return NextResponse.json({ error: 'Invalid api key' }, { status: 400 });
+    }
+    const validationError = validateIds({ assistantId, mcpServerId });
+    if (validationError)
+        return validationError;
+    const mcpServer = await prisma.mcpServer.findFirst({
+        where: {
+            id: mcpServerId,
+            assistant: {
+                id: assistantId,
+                workspaceId: privateApiKey.workspaceId,
+            },
+        },
+        include: {
+            sseTransport: true,
+            httpTransport: true,
+        },
+    });
+    if (!mcpServer) {
+        return NextResponse.json({ error: 'No MCP server found' }, { status: 400 });
+    }
+    return NextResponse.json({
+        mcpServer: serializeApiMcpServer({ mcpServer }),
+    }, { headers: cacheHeaders });
+};
+export const buildPATCH = ({ prisma }) => async (request, props) => {
+    const { assistantId, mcpServerId } = await props.params;
+    const headersList = await headers();
+    const authorization = headersList.get('authorization');
+    if (!authorization) {
+        return NextResponse.json({ error: 'No authorization header found' }, { status: 400 });
+    }
+    const privateApiKey = await getApiKey({
+        authorization,
+        type: ApiKeyType.PRIVATE,
+        prisma,
+    });
+    if (!privateApiKey) {
+        return NextResponse.json({ error: 'Invalid api key' }, { status: 400 });
+    }
+    const validationError = validateIds({ assistantId, mcpServerId });
+    if (validationError)
+        return validationError;
+    const body = await request.json();
+    const parsed = mcpServerSchema.safeParse(body);
+    if (!parsed.success) {
+        return NextResponse.json({ error: 'Invalid payload' }, { status: 400 });
+    }
+    const { transportType, sseTransport, httpTransport } = parsed.data;
+    const mcpServer = await prisma.mcpServer.findFirst({
+        where: {
+            id: mcpServerId,
+            assistant: {
+                id: assistantId,
+                workspaceId: privateApiKey.workspaceId,
+            },
+        },
+    });
+    if (!mcpServer) {
+        return NextResponse.json({ error: 'No MCP server found' }, { status: 400 });
+    }
+    const updatedMcpServer = await prisma.mcpServer.update({
+        where: {
+            id: mcpServerId,
+        },
+        data: Object.assign(Object.assign({ transportType }, (transportType === TransportType.SSE
+            ? {
+                sseTransport: {
+                    update: {
+                        url: sseTransport.url,
+                        headers: JSON.parse(sseTransport.headers),
+                    },
+                },
+            }
+            : {})), (transportType === TransportType.HTTP
+            ? {
+                httpTransport: {
+                    update: {
+                        url: httpTransport.url,
+                        headers: JSON.parse(httpTransport.headers),
+                    },
+                },
+            }
+            : {})),
+        include: {
+            sseTransport: true,
+            httpTransport: true,
+        },
+    });
+    return NextResponse.json({
+        mcpServer: serializeApiMcpServer({ mcpServer: updatedMcpServer }),
+    }, { headers: cacheHeaders });
+};
+export const buildDELETE = ({ prisma }) => async (_request, props) => {
+    const { assistantId, mcpServerId } = await props.params;
+    const headersList = await headers();
+    const authorization = headersList.get('authorization');
+    if (!authorization) {
+        return NextResponse.json({ error: 'No authorization header found' }, { status: 400 });
+    }
+    const privateApiKey = await getApiKey({
+        authorization,
+        type: ApiKeyType.PRIVATE,
+        prisma,
+    });
+    if (!privateApiKey) {
+        return NextResponse.json({ error: 'Invalid api key' }, { status: 400 });
+    }
+    const validationError = validateIds({ assistantId, mcpServerId });
+    if (validationError)
+        return validationError;
+    const mcpServer = await prisma.mcpServer.findFirst({
+        where: {
+            id: mcpServerId,
+            assistant: {
+                id: assistantId,
+                workspaceId: privateApiKey.workspaceId,
+            },
+        },
+    });
+    if (!mcpServer) {
+        return NextResponse.json({ error: 'No MCP server found' }, { status: 400 });
+    }
+    const deletedMcpServer = await prisma.mcpServer.delete({
+        where: { id: mcpServerId },
+        include: {
+            sseTransport: true,
+            httpTransport: true,
+        },
+    });
+    return NextResponse.json({
+        mcpServer: serializeApiMcpServer({ mcpServer: deletedMcpServer }),
+    }, { headers: cacheHeaders });
+};
+export const buildOPTIONS = () => () => NextResponse.json({}, {
+    headers: cacheHeaders,
+});

package/dist/app/api/assistants/[assistantId]/mcp-servers/[mcpServerId]/route.d.ts

@@ -1,15 +1,11 @@
-import { type PrismaClient } from '@prisma/client';
-import { NextResponse, type NextRequest } from 'next/server';
-export declare const buildGET: ({ prisma: providedPrisma }?: {
-    prisma?: PrismaClient;
-}) => (_request: NextRequest, props: {
+export declare const GET: (_request: import("next/server").NextRequest, props: {
     params: Promise<{
         assistantId: string;
         mcpServerId: string;
     }>;
-}) => Promise<NextResponse<{
+}) => Promise<import("next/server").NextResponse<{
     error: string;
-}> | NextResponse<{
+}> | import("next/server").NextResponse<{
     mcpServer: {
         id: string;
         transportType: import("@prisma/client").$Enums.TransportType;
@@ -31,17 +27,14 @@ export declare const buildGET: ({ prisma: providedPrisma }?: {
         updatedAt: string;
     };
 }>>;
-export declare const GET: ReturnType<typeof buildGET>;
-export declare const buildPATCH: ({ prisma: providedPrisma }?: {
-    prisma?: PrismaClient;
-}) => (request: NextRequest, props: {
+export declare const PATCH: (request: import("next/server").NextRequest, props: {
     params: Promise<{
         assistantId: string;
         mcpServerId: string;
     }>;
-}) => Promise<NextResponse<{
+}) => Promise<import("next/server").NextResponse<{
     error: string;
-}> | NextResponse<{
+}> | import("next/server").NextResponse<{
     mcpServer: {
         id: string;
         transportType: import("@prisma/client").$Enums.TransportType;
@@ -63,17 +56,14 @@ export declare const buildPATCH: ({ prisma: providedPrisma }?: {
         updatedAt: string;
     };
 }>>;
-export declare const PATCH: ReturnType<typeof buildPATCH>;
-export declare const buildDELETE: ({ prisma: providedPrisma }?: {
-    prisma?: PrismaClient;
-}) => (_request: NextRequest, props: {
+export declare const DELETE: (_request: import("next/server").NextRequest, props: {
     params: Promise<{
         assistantId: string;
         mcpServerId: string;
     }>;
-}) => Promise<NextResponse<{
+}) => Promise<import("next/server").NextResponse<{
     error: string;
-}> | NextResponse<{
+}> | import("next/server").NextResponse<{
     mcpServer: {
         id: string;
         transportType: import("@prisma/client").$Enums.TransportType;
@@ -95,6 +85,5 @@ export declare const buildDELETE: ({ prisma: providedPrisma }?: {
         updatedAt: string;
     };
 }>>;
-export declare const DELETE: ReturnType<typeof buildDELETE>;
-export declare const OPTIONS: () => NextResponse<{}>;
+export declare const OPTIONS: () => import("next/server").NextResponse<{}>;
 //# sourceMappingURL=route.d.ts.map

package/dist/app/api/assistants/[assistantId]/mcp-servers/[mcpServerId]/route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../../../src/app/api/assistants/[assistantId]/mcp-servers/[mcpServerId]/route.ts"],"names":[],"mappings":"AACA,OAAO,EAA6B,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC7E,OAAO,EAAE,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,aAAa,CAAA;AAQ5D,eAAO,MAAM,QAAQ,GAClB,6BAA4B;IAAE,MAAM,CAAC,EAAE,YAAY,CAAA;CAAO,MAEzD,UAAU,WAAW,EACrB,OAAO;IACL,MAAM,EAAE,OAAO,CAAC;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAC9D;;;;;;;;;;;;;;;;;;;;;;;GAiEF,CAAA;AAEH,eAAO,MAAM,GAAG,EACU,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAA;AAErD,eAAO,MAAM,UAAU,GACpB,6BAA4B;IAAE,MAAM,CAAC,EAAE,YAAY,CAAA;CAAO,MAEzD,SAAS,WAAW,EACpB,OAAO;IACL,MAAM,EAAE,OAAO,CAAC;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAC9D;;;;;;;;;;;;;;;;;;;;;;;GAwGF,CAAA;AAEH,eAAO,MAAM,KAAK,EACU,UAAU,CAAC,OAAO,UAAU,CAAC,CAAA;AAEzD,eAAO,MAAM,WAAW,GACrB,6BAA4B;IAAE,MAAM,CAAC,EAAE,YAAY,CAAA;CAAO,MAEzD,UAAU,WAAW,EACrB,OAAO;IACL,MAAM,EAAE,OAAO,CAAC;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAC9D;;;;;;;;;;;;;;;;;;;;;;;GAqEF,CAAA;AAEH,eAAO,MAAM,MAAM,EACU,UAAU,CAAC,OAAO,WAAW,CAAC,CAAA;AAE3D,eAAO,MAAM,OAAO,wBAMjB,CAAA"}
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../../../src/app/api/assistants/[assistantId]/mcp-servers/[mcpServerId]/route.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAuB,CAAA;AAEvC,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAyB,CAAA;AAE3C,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA0B,CAAA;AAE7C,eAAO,MAAM,OAAO,8CAAiB,CAAA"}

package/dist/app/api/assistants/[assistantId]/mcp-servers/[mcpServerId]/route.js

@@ -1,174 +1,6 @@
-import { headers } from 'next/headers';
-import { ApiKeyType, TransportType } from '@prisma/client';
-import { NextResponse } from 'next/server';
-import { cacheHeaders } from '../../../../../../lib/cache/cacheHeaders';
-import { resolvePrisma } from '../../../../../../lib/prisma';
-import { getApiKey } from '../../../../../../lib/apiKeys/getApiKey';
-import { validate } from 'uuid';
-import { serializeApiMcpServer } from '../../../../../../lib/mcpServers/serializeApiMcpServer';
-import { mcpServerSchema } from '../../../../../../lib/mcpServers/mcpServerSchema';
-export const buildGET = ({ prisma: providedPrisma } = {}) => async (_request, props) => {
-    const prisma = resolvePrisma(providedPrisma);
-    const { assistantId, mcpServerId } = await props.params;
-    const headersList = await headers();
-    const authorization = headersList.get('authorization');
-    if (!authorization) {
-        return NextResponse.json({ error: 'No authorization header found' }, { status: 400 });
-    }
-    const privateApiKey = await getApiKey({
-        type: ApiKeyType.PRIVATE,
-        authorization,
-        prisma,
-    });
-    if (!privateApiKey) {
-        return NextResponse.json({ error: 'Invalid api key' }, { status: 400 });
-    }
-    if (!validate(assistantId)) {
-        return NextResponse.json({ error: 'Invalid assistant id' }, { status: 400 });
-    }
-    if (!validate(mcpServerId)) {
-        return NextResponse.json({ error: 'Invalid MCP server id' }, { status: 400 });
-    }
-    const mcpServer = await prisma.mcpServer.findFirst({
-        where: {
-            id: mcpServerId,
-            assistant: {
-                id: assistantId,
-                workspaceId: privateApiKey.workspaceId,
-            },
-        },
-        include: {
-            sseTransport: true,
-            httpTransport: true,
-        },
-    });
-    if (!mcpServer) {
-        return NextResponse.json({ error: 'No MCP server found' }, { status: 400 });
-    }
-    return NextResponse.json({
-        mcpServer: serializeApiMcpServer({ mcpServer }),
-    }, { headers: cacheHeaders });
-};
-export const GET = ((...args) => buildGET()(...args));
-export const buildPATCH = ({ prisma: providedPrisma } = {}) => async (request, props) => {
-    const prisma = resolvePrisma(providedPrisma);
-    const { assistantId, mcpServerId } = await props.params;
-    const headersList = await headers();
-    const authorization = headersList.get('authorization');
-    if (!authorization) {
-        return NextResponse.json({ error: 'No authorization header found' }, { status: 400 });
-    }
-    const privateApiKey = await getApiKey({
-        authorization,
-        type: ApiKeyType.PRIVATE,
-        prisma,
-    });
-    if (!privateApiKey) {
-        return NextResponse.json({ error: 'Invalid api key' }, { status: 400 });
-    }
-    if (!validate(assistantId)) {
-        return NextResponse.json({ error: 'Invalid assistant id' }, { status: 400 });
-    }
-    if (!validate(mcpServerId)) {
-        return NextResponse.json({ error: 'Invalid MCP server id' }, { status: 400 });
-    }
-    const body = await request.json();
-    const parsed = mcpServerSchema.safeParse(body);
-    if (!parsed.success) {
-        return NextResponse.json({ error: 'Invalid payload' }, { status: 400 });
-    }
-    const { transportType, sseTransport, httpTransport } = parsed.data;
-    const mcpServer = await prisma.mcpServer.findFirst({
-        where: {
-            id: mcpServerId,
-            assistant: {
-                id: assistantId,
-                workspaceId: privateApiKey.workspaceId,
-            },
-        },
-    });
-    if (!mcpServer) {
-        return NextResponse.json({ error: 'No MCP server found' }, { status: 400 });
-    }
-    const updatedMcpServer = await prisma.mcpServer.update({
-        where: {
-            id: mcpServerId,
-        },
-        data: Object.assign(Object.assign({ transportType }, (transportType === TransportType.SSE
-            ? {
-                sseTransport: {
-                    update: {
-                        url: sseTransport.url,
-                        headers: JSON.parse(sseTransport.headers),
-                    },
-                },
-            }
-            : {})), (transportType === TransportType.HTTP
-            ? {
-                httpTransport: {
-                    update: {
-                        url: httpTransport.url,
-                        headers: JSON.parse(httpTransport.headers),
-                    },
-                },
-            }
-            : {})),
-        include: {
-            sseTransport: true,
-            httpTransport: true,
-        },
-    });
-    return NextResponse.json({
-        mcpServer: serializeApiMcpServer({ mcpServer: updatedMcpServer }),
-    }, { headers: cacheHeaders });
-};
-export const PATCH = ((...args) => buildPATCH()(...args));
-export const buildDELETE = ({ prisma: providedPrisma } = {}) => async (_request, props) => {
-    const prisma = resolvePrisma(providedPrisma);
-    const { assistantId, mcpServerId } = await props.params;
-    const headersList = await headers();
-    const authorization = headersList.get('authorization');
-    if (!authorization) {
-        return NextResponse.json({ error: 'No authorization header found' }, { status: 400 });
-    }
-    const privateApiKey = await getApiKey({
-        authorization,
-        type: ApiKeyType.PRIVATE,
-        prisma,
-    });
-    if (!privateApiKey) {
-        return NextResponse.json({ error: 'Invalid api key' }, { status: 400 });
-    }
-    if (!validate(assistantId)) {
-        return NextResponse.json({ error: 'Invalid assistant id' }, { status: 400 });
-    }
-    if (!validate(mcpServerId)) {
-        return NextResponse.json({ error: 'Invalid MCP server id' }, { status: 400 });
-    }
-    const mcpServer = await prisma.mcpServer.findFirst({
-        where: {
-            id: mcpServerId,
-            assistant: {
-                id: assistantId,
-                workspaceId: privateApiKey.workspaceId,
-            },
-        },
-    });
-    if (!mcpServer) {
-        return NextResponse.json({ error: 'No MCP server found' }, { status: 400 });
-    }
-    const deletedMcpServer = await prisma.mcpServer.delete({
-        where: { id: mcpServerId },
-        include: {
-            sseTransport: true,
-            httpTransport: true,
-        },
-    });
-    return NextResponse.json({
-        mcpServer: serializeApiMcpServer({ mcpServer: deletedMcpServer }),
-    }, { headers: cacheHeaders });
-};
-export const DELETE = ((...args) => buildDELETE()(...args));
-export const OPTIONS = () => NextResponse.json({}, {
-    headers: cacheHeaders,
-});
+import { prisma } from '../../../../../../lib/prisma';
+import { buildDELETE, buildGET, buildOPTIONS, buildPATCH, } from './buildRoute';
+export const GET = buildGET({ prisma });
+export const PATCH = buildPATCH({ prisma });
+export const DELETE = buildDELETE({ prisma });
+export const OPTIONS = buildOPTIONS();

package/dist/app/api/assistants/[assistantId]/mcp-servers/buildRoute.d.ts

@@ -0,0 +1,62 @@
+import { type NextRequest, NextResponse } from 'next/server';
+import { type PrismaClient } from '@prisma/client';
+type RouteProps = {
+    params: Promise<{
+        assistantId: string;
+    }>;
+};
+export declare const buildGET: ({ prisma }: {
+    prisma: PrismaClient;
+}) => (_request: NextRequest, props: RouteProps) => Promise<NextResponse<{
+    error: string;
+}> | NextResponse<{
+    mcpServers: {
+        id: string;
+        transportType: import("@prisma/client").$Enums.TransportType;
+        sseTransport: {
+            id: string;
+            url: string;
+            headers: PrismaJson.SseTransportHeaders;
+            createdAt: string;
+            updatedAt: string;
+        } | null;
+        httpTransport: {
+            id: string;
+            url: string;
+            headers: PrismaJson.HttpTransportHeaders;
+            createdAt: string;
+            updatedAt: string;
+        } | null;
+        createdAt: string;
+        updatedAt: string;
+    }[];
+}>>;
+export declare const buildPOST: ({ prisma }: {
+    prisma: PrismaClient;
+}) => (request: NextRequest, props: RouteProps) => Promise<NextResponse<{
+    error: string;
+}> | NextResponse<{
+    mcpServer: {
+        id: string;
+        transportType: import("@prisma/client").$Enums.TransportType;
+        sseTransport: {
+            id: string;
+            url: string;
+            headers: PrismaJson.SseTransportHeaders;
+            createdAt: string;
+            updatedAt: string;
+        } | null;
+        httpTransport: {
+            id: string;
+            url: string;
+            headers: PrismaJson.HttpTransportHeaders;
+            createdAt: string;
+            updatedAt: string;
+        } | null;
+        createdAt: string;
+        updatedAt: string;
+    };
+}>>;
+export declare const buildOPTIONS: () => () => NextResponse<{}>;
+export {};
+//# sourceMappingURL=buildRoute.d.ts.map

package/dist/app/api/assistants/[assistantId]/mcp-servers/buildRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildRoute.d.ts","sourceRoot":"","sources":["../../../../../../src/app/api/assistants/[assistantId]/mcp-servers/buildRoute.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC5D,OAAO,EAA6B,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAO7E,KAAK,UAAU,GAAG;IAChB,MAAM,EAAE,OAAO,CAAC;QAAE,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CACzC,CAAA;AAED,eAAO,MAAM,QAAQ,GAClB,YAAY;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE,MAC9B,UAAU,WAAW,EAAE,OAAO,UAAU;;;;;;;;;;;;;;;;;;;;;;;GAuD9C,CAAA;AAEH,eAAO,MAAM,SAAS,GACnB,YAAY;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE,MAC9B,SAAS,WAAW,EAAE,OAAO,UAAU;;;;;;;;;;;;;;;;;;;;;;;GAoF7C,CAAA;AAEH,eAAO,MAAM,YAAY,8BAMtB,CAAA"}

package/dist/app/api/assistants/[assistantId]/mcp-servers/buildRoute.js

@@ -0,0 +1,115 @@
+import { NextResponse } from 'next/server';
+import { ApiKeyType, TransportType } from '@prisma/client';
+import { headers } from 'next/headers';
+import { cacheHeaders } from '../../../../../lib/cache/cacheHeaders';
+import { getApiKey } from '../../../../../lib/apiKeys/getApiKey';
+import { serializeApiMcpServer } from '../../../../../lib/mcpServers/serializeApiMcpServer';
+import { mcpServerSchema } from '../../../../../lib/mcpServers/mcpServerSchema';
+export const buildGET = ({ prisma }) => async (_request, props) => {
+    const { assistantId } = await props.params;
+    const headersList = await headers();
+    const authorization = headersList.get('authorization');
+    if (!authorization) {
+        return NextResponse.json({ error: 'No authorization header found' }, { status: 400 });
+    }
+    const privateApiKey = await getApiKey({
+        type: ApiKeyType.PRIVATE,
+        authorization,
+        prisma,
+    });
+    if (!privateApiKey) {
+        return NextResponse.json({ error: 'Invalid api key' }, { status: 400 });
+    }
+    const assistant = await prisma.assistant.findFirst({
+        where: {
+            id: assistantId,
+            workspaceId: privateApiKey.workspaceId,
+        },
+        include: {
+            mcpServers: {
+                include: {
+                    stdioTransport: true,
+                    sseTransport: true,
+                    httpTransport: true,
+                },
+                orderBy: {
+                    createdAt: 'desc',
+                },
+            },
+        },
+    });
+    if (!assistant) {
+        return NextResponse.json({ error: 'No assistant found' }, { status: 400 });
+    }
+    return NextResponse.json({
+        mcpServers: assistant.mcpServers.map((mcpServer) => serializeApiMcpServer({
+            mcpServer,
+        })),
+    }, { headers: cacheHeaders });
+};
+export const buildPOST = ({ prisma }) => async (request, props) => {
+    const { assistantId } = await props.params;
+    const headersList = await headers();
+    const authorization = headersList.get('authorization');
+    if (!authorization) {
+        return NextResponse.json({ error: 'No authorization header found' }, { status: 400 });
+    }
+    const privateApiKey = await getApiKey({
+        authorization,
+        type: ApiKeyType.PRIVATE,
+        prisma,
+    });
+    if (!privateApiKey) {
+        return NextResponse.json({ error: 'Invalid api key' }, { status: 400 });
+    }
+    const body = await request.json();
+    const parsed = mcpServerSchema.safeParse(body);
+    if (!parsed.success) {
+        return NextResponse.json({ error: 'Invalid payload' }, { status: 400 });
+    }
+    const { transportType, sseTransport, httpTransport } = parsed.data;
+    const workspaceId = privateApiKey.workspaceId;
+    const assistant = await prisma.assistant.findFirst({
+        where: { id: assistantId, workspaceId },
+    });
+    if (!assistant) {
+        return NextResponse.json({ error: 'No assistant found' }, { status: 400 });
+    }
+    const mcpServer = await prisma.mcpServer.create({
+        data: Object.assign(Object.assign(Object.assign({ transportType }, (transportType === TransportType.SSE
+            ? {
+                sseTransport: {
+                    create: {
+                        url: sseTransport.url,
+                        headers: JSON.parse(sseTransport.headers),
+                    },
+                },
+            }
+            : {})), (transportType === TransportType.HTTP
+            ? {
+                httpTransport: {
+                    create: {
+                        url: httpTransport.url,
+                        headers: JSON.parse(httpTransport.headers),
+                    },
+                },
+            }
+            : {})), { assistant: {
+                connect: {
+                    id: assistantId,
+                    workspaceId,
+                },
+            } }),
+        include: {
+            stdioTransport: true,
+            sseTransport: true,
+            httpTransport: true,
+        },
+    });
+    return NextResponse.json({
+        mcpServer: serializeApiMcpServer({ mcpServer }),
+    }, { headers: cacheHeaders });
+};
+export const buildOPTIONS = () => () => NextResponse.json({}, {
+    headers: cacheHeaders,
+});

package/dist/app/api/assistants/[assistantId]/mcp-servers/route.d.ts

@@ -1,14 +1,10 @@
-import { type NextRequest, NextResponse } from 'next/server';
-import { type PrismaClient } from '@prisma/client';
-export declare const buildGET: ({ prisma: providedPrisma }?: {
-    prisma?: PrismaClient;
-}) => (_request: NextRequest, props: {
+export declare const GET: (_request: import("next/server").NextRequest, props: {
     params: Promise<{
         assistantId: string;
     }>;
-}) => Promise<NextResponse<{
+}) => Promise<import("next/server").NextResponse<{
     error: string;
-}> | NextResponse<{
+}> | import("next/server").NextResponse<{
     mcpServers: {
         id: string;
         transportType: import("@prisma/client").$Enums.TransportType;
@@ -30,16 +26,13 @@ export declare const buildGET: ({ prisma: providedPrisma }?: {
         updatedAt: string;
     }[];
 }>>;
-export declare const GET: ReturnType<typeof buildGET>;
-export declare const buildPOST: ({ prisma: providedPrisma }?: {
-    prisma?: PrismaClient;
-}) => (request: NextRequest, props: {
+export declare const POST: (request: import("next/server").NextRequest, props: {
     params: Promise<{
         assistantId: string;
     }>;
-}) => Promise<NextResponse<{
+}) => Promise<import("next/server").NextResponse<{
     error: string;
-}> | NextResponse<{
+}> | import("next/server").NextResponse<{
     mcpServer: {
         id: string;
         transportType: import("@prisma/client").$Enums.TransportType;
@@ -61,6 +54,5 @@ export declare const buildPOST: ({ prisma: providedPrisma }?: {
         updatedAt: string;
     };
 }>>;
-export declare const POST: ReturnType<typeof buildPOST>;
-export declare const OPTIONS: () => NextResponse<{}>;
+export declare const OPTIONS: () => import("next/server").NextResponse<{}>;
 //# sourceMappingURL=route.d.ts.map

package/dist/app/api/assistants/[assistantId]/mcp-servers/route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../../src/app/api/assistants/[assistantId]/mcp-servers/route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC5D,OAAO,EAA6B,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAQ7E,eAAO,MAAM,QAAQ,GAClB,6BAA4B;IAAE,MAAM,CAAC,EAAE,YAAY,CAAA;CAAO,MAEzD,UAAU,WAAW,EACrB,OAAO;IACL,MAAM,EAAE,OAAO,CAAC;QAAE,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CACzC;;;;;;;;;;;;;;;;;;;;;;;GAyDF,CAAA;AAEH,eAAO,MAAM,GAAG,EACU,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAA;AAErD,eAAO,MAAM,SAAS,GACnB,6BAA4B;IAAE,MAAM,CAAC,EAAE,YAAY,CAAA;CAAO,MAEzD,SAAS,WAAW,EACpB,OAAO;IACL,MAAM,EAAE,OAAO,CAAC;QAAE,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CACzC;;;;;;;;;;;;;;;;;;;;;;;GAsFF,CAAA;AAEH,eAAO,MAAM,IAAI,EACU,UAAU,CAAC,OAAO,SAAS,CAAC,CAAA;AAEvD,eAAO,MAAM,OAAO,wBAMjB,CAAA"}
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../../src/app/api/assistants/[assistantId]/mcp-servers/route.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAuB,CAAA;AAEvC,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAwB,CAAA;AAEzC,eAAO,MAAM,OAAO,8CAAiB,CAAA"}