@superinterface/server 1.0.24 → 1.0.26

package/dist/app/api/assistants/[assistantId]/functions/buildRoute.js

@@ -0,0 +1,117 @@
+import { NextResponse } from 'next/server';
+import { ApiKeyType } from '@prisma/client';
+import { headers } from 'next/headers';
+import { cacheHeaders } from '../../../../../lib/cache/cacheHeaders';
+import { getApiKey } from '../../../../../lib/apiKeys/getApiKey';
+import { serializeApiFunction } from '../../../../../lib/functions/serializeApiFunction';
+import { functionSchema } from '../../../../../lib/functions/functionSchema';
+import { createFunction } from '../../../../../lib/functions/createFunction';
+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: {
+            functions: {
+                include: {
+                    handler: {
+                        include: {
+                            requestHandler: true,
+                            firecrawlHandler: true,
+                            replicateHandler: true,
+                            clientToolHandler: true,
+                            assistantHandler: true,
+                            createTaskHandler: true,
+                            listTasksHandler: true,
+                            updateTaskHandler: true,
+                            deleteTaskHandler: true,
+                        },
+                    },
+                },
+                orderBy: {
+                    createdAt: 'desc',
+                },
+            },
+        },
+    });
+    if (!assistant) {
+        return NextResponse.json({ error: 'No assistant found' }, { status: 400 });
+    }
+    return NextResponse.json({
+        functions: assistant.functions.map((fn) => serializeApiFunction({
+            fn,
+        })),
+    }, { 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 assistant = await prisma.assistant.findFirst({
+        where: {
+            id: assistantId,
+            workspaceId: privateApiKey.workspaceId,
+        },
+    });
+    if (!assistant) {
+        return NextResponse.json({ error: 'No assistant found' }, { status: 400 });
+    }
+    const body = await request.json();
+    const parsed = functionSchema.safeParse(body);
+    if (!parsed.success) {
+        console.error('Function creation error:', parsed.error);
+        return NextResponse.json({ error: 'Invalid payload' }, { status: 400 });
+    }
+    const fn = await createFunction({
+        parsedInput: parsed.data,
+        assistant,
+        include: {
+            handler: {
+                include: {
+                    requestHandler: true,
+                    firecrawlHandler: true,
+                    replicateHandler: true,
+                    clientToolHandler: true,
+                    assistantHandler: true,
+                    createTaskHandler: true,
+                    listTasksHandler: true,
+                    updateTaskHandler: true,
+                    deleteTaskHandler: true,
+                },
+            },
+        },
+        prisma,
+    });
+    return NextResponse.json({
+        function: serializeApiFunction({ fn }),
+    }, { headers: cacheHeaders });
+};
+export const buildOPTIONS = () => () => NextResponse.json({}, {
+    headers: cacheHeaders,
+});

package/dist/app/api/assistants/[assistantId]/functions/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<{
     functions: {
         id: string;
         openapiSpec: PrismaJson.OpenapiSpec;
@@ -56,16 +52,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<{
     function: {
         id: string;
         openapiSpec: PrismaJson.OpenapiSpec;
@@ -113,6 +106,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]/functions/route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../../src/app/api/assistants/[assistantId]/functions/route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC5D,OAAO,EAAc,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAS9D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEF,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsEF,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]/functions/route.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAuB,CAAA;AAEvC,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAwB,CAAA;AAEzC,eAAO,MAAM,OAAO,8CAAiB,CAAA"}

package/dist/app/api/assistants/[assistantId]/functions/route.js

@@ -1,122 +1,5 @@
-import { NextResponse } from 'next/server';
-import { ApiKeyType } from '@prisma/client';
-import { headers } from 'next/headers';
-import { cacheHeaders } from '../../../../../lib/cache/cacheHeaders';
-import { resolvePrisma } from '../../../../../lib/prisma';
-import { getApiKey } from '../../../../../lib/apiKeys/getApiKey';
-import { serializeApiFunction } from '../../../../../lib/functions/serializeApiFunction';
-import { functionSchema } from '../../../../../lib/functions/functionSchema';
-import { createFunction } from '../../../../../lib/functions/createFunction';
-export const buildGET = ({ prisma: providedPrisma } = {}) => async (_request, props) => {
-    const prisma = resolvePrisma(providedPrisma);
-    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: {
-            functions: {
-                include: {
-                    handler: {
-                        include: {
-                            requestHandler: true,
-                            firecrawlHandler: true,
-                            replicateHandler: true,
-                            clientToolHandler: true,
-                            assistantHandler: true,
-                            createTaskHandler: true,
-                            listTasksHandler: true,
-                            updateTaskHandler: true,
-                            deleteTaskHandler: true,
-                        },
-                    },
-                },
-                orderBy: {
-                    createdAt: 'desc',
-                },
-            },
-        },
-    });
-    if (!assistant) {
-        return NextResponse.json({ error: 'No assistant found' }, { status: 400 });
-    }
-    return NextResponse.json({
-        functions: assistant.functions.map((fn) => serializeApiFunction({
-            fn,
-        })),
-    }, { headers: cacheHeaders });
-};
-export const GET = ((...args) => buildGET()(...args));
-export const buildPOST = ({ prisma: providedPrisma } = {}) => async (request, props) => {
-    const prisma = resolvePrisma(providedPrisma);
-    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 assistant = await prisma.assistant.findFirst({
-        where: {
-            id: assistantId,
-            workspaceId: privateApiKey.workspaceId,
-        },
-    });
-    if (!assistant) {
-        return NextResponse.json({ error: 'No assistant found' }, { status: 400 });
-    }
-    const body = await request.json();
-    const parsed = functionSchema.safeParse(body);
-    if (!parsed.success) {
-        console.error('Function creation error:', parsed.error);
-        return NextResponse.json({ error: 'Invalid payload' }, { status: 400 });
-    }
-    const fn = await createFunction({
-        parsedInput: parsed.data,
-        assistant,
-        include: {
-            handler: {
-                include: {
-                    requestHandler: true,
-                    firecrawlHandler: true,
-                    replicateHandler: true,
-                    clientToolHandler: true,
-                    assistantHandler: true,
-                    createTaskHandler: true,
-                    listTasksHandler: true,
-                    updateTaskHandler: true,
-                    deleteTaskHandler: true,
-                },
-            },
-        },
-        prisma,
-    });
-    return NextResponse.json({
-        function: serializeApiFunction({ fn }),
-    }, { headers: cacheHeaders });
-};
-export const POST = ((...args) => buildPOST()(...args));
-export const OPTIONS = () => NextResponse.json({}, {
-    headers: cacheHeaders,
-});
+import { prisma } from '../../../../../lib/prisma';
+import { buildGET, buildOPTIONS, buildPOST, } from './buildRoute';
+export const GET = buildGET({ prisma });
+export const POST = buildPOST({ prisma });
+export const OPTIONS = buildOPTIONS();

package/dist/app/api/assistants/[assistantId]/initial-messages/buildRoute.d.ts

@@ -0,0 +1,40 @@
+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<{
+    initialMessages: {
+        id: string;
+        role: import("@prisma/client").$Enums.MessageRole;
+        content: string;
+        orderNumber: number;
+        assistantId: string | null;
+        createdAt: string;
+        updatedAt: string;
+    }[];
+}>>;
+export declare const buildPUT: ({ prisma }: {
+    prisma: PrismaClient;
+}) => (request: NextRequest, props: RouteProps) => Promise<NextResponse<{
+    error: string;
+}> | NextResponse<{
+    initialMessages: {
+        id: string;
+        role: import("@prisma/client").$Enums.MessageRole;
+        content: string;
+        orderNumber: number;
+        assistantId: string | null;
+        createdAt: string;
+        updatedAt: string;
+    }[];
+}>>;
+export declare const buildOPTIONS: () => () => NextResponse<{}>;
+export {};
+//# sourceMappingURL=buildRoute.d.ts.map

package/dist/app/api/assistants/[assistantId]/initial-messages/buildRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildRoute.d.ts","sourceRoot":"","sources":["../../../../../../src/app/api/assistants/[assistantId]/initial-messages/buildRoute.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC5D,OAAO,EAA8B,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAQ9E,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;;;;;;;;;;;;GAgD9C,CAAA;AAEH,eAAO,MAAM,QAAQ,GAClB,YAAY;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE,MAC9B,SAAS,WAAW,EAAE,OAAO,UAAU;;;;;;;;;;;;GAuD7C,CAAA;AAEH,eAAO,MAAM,YAAY,8BAMtB,CAAA"}

package/dist/app/api/assistants/[assistantId]/initial-messages/buildRoute.js

@@ -0,0 +1,85 @@
+import { NextResponse } from 'next/server';
+import { ApiKeyType } from '@prisma/client';
+import { headers } from 'next/headers';
+import { cacheHeaders } from '../../../../../lib/cache/cacheHeaders';
+import { serializeApiInitialMessage } from '../../../../../lib/initialMessages/serializeApiInitialMessage';
+import { initialMessagesSchema } from '../../../../../lib/initialMessages/schema';
+import { updateInitialMessages } from '../../../../../lib/initialMessages/updateInitialMessages';
+import { getApiKey } from '../../../../../lib/apiKeys/getApiKey';
+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: {
+            initialMessages: {
+                orderBy: {
+                    orderNumber: 'asc',
+                },
+            },
+        },
+    });
+    if (!assistant) {
+        return NextResponse.json({ error: 'No assistant found' }, { status: 400 });
+    }
+    return NextResponse.json({
+        initialMessages: assistant.initialMessages.map((m) => serializeApiInitialMessage({ initialMessage: m })),
+    }, { headers: cacheHeaders });
+};
+export const buildPUT = ({ 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 bodyParse = initialMessagesSchema.safeParse(body);
+    if (!bodyParse.success) {
+        return NextResponse.json({ error: 'Invalid body' }, { status: 400 });
+    }
+    const { initialMessages } = bodyParse.data;
+    const assistant = await prisma.assistant.findFirst({
+        where: {
+            id: assistantId,
+            workspaceId: privateApiKey.workspaceId,
+        },
+    });
+    if (!assistant) {
+        return NextResponse.json({ error: 'No assistant found' }, { status: 400 });
+    }
+    const messages = await updateInitialMessages({
+        assistantId: assistant.id,
+        initialMessages,
+        prisma,
+    });
+    return NextResponse.json({
+        initialMessages: messages.map((m) => serializeApiInitialMessage({ initialMessage: m })),
+    }, { headers: cacheHeaders });
+};
+export const buildOPTIONS = () => () => NextResponse.json({}, {
+    headers: cacheHeaders,
+});

package/dist/app/api/assistants/[assistantId]/initial-messages/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<{
     initialMessages: {
         id: string;
         role: import("@prisma/client").$Enums.MessageRole;
@@ -19,16 +15,13 @@ export declare const buildGET: ({ prisma: providedPrisma }?: {
         updatedAt: string;
     }[];
 }>>;
-export declare const GET: ReturnType<typeof buildGET>;
-export declare const buildPUT: ({ prisma: providedPrisma }?: {
-    prisma?: PrismaClient;
-}) => (request: NextRequest, props: {
+export declare const PUT: (request: import("next/server").NextRequest, props: {
     params: Promise<{
         assistantId: string;
     }>;
-}) => Promise<NextResponse<{
+}) => Promise<import("next/server").NextResponse<{
     error: string;
-}> | NextResponse<{
+}> | import("next/server").NextResponse<{
     initialMessages: {
         id: string;
         role: import("@prisma/client").$Enums.MessageRole;
@@ -39,6 +32,5 @@ export declare const buildPUT: ({ prisma: providedPrisma }?: {
         updatedAt: string;
     }[];
 }>>;
-export declare const PUT: ReturnType<typeof buildPUT>;
-export declare const OPTIONS: () => NextResponse<{}>;
+export declare const OPTIONS: () => import("next/server").NextResponse<{}>;
 //# sourceMappingURL=route.d.ts.map

package/dist/app/api/assistants/[assistantId]/initial-messages/route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../../src/app/api/assistants/[assistantId]/initial-messages/route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC5D,OAAO,EAA8B,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAS9E,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;;;;;;;;;;;;GAkDF,CAAA;AAEH,eAAO,MAAM,GAAG,EACU,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAA;AAErD,eAAO,MAAM,QAAQ,GAClB,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;;;;;;;;;;;;GAyDF,CAAA;AAEH,eAAO,MAAM,GAAG,EACU,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAA;AAErD,eAAO,MAAM,OAAO,wBAMjB,CAAA"}
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../../src/app/api/assistants/[assistantId]/initial-messages/route.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;GAAuB,CAAA;AAEvC,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;GAAuB,CAAA;AAEvC,eAAO,MAAM,OAAO,8CAAiB,CAAA"}

package/dist/app/api/assistants/[assistantId]/initial-messages/route.js

@@ -1,90 +1,5 @@
-import { NextResponse } from 'next/server';
-import { ApiKeyType } from '@prisma/client';
-import { headers } from 'next/headers';
-import { cacheHeaders } from '../../../../../lib/cache/cacheHeaders';
-import { resolvePrisma } from '../../../../../lib/prisma';
-import { serializeApiInitialMessage } from '../../../../../lib/initialMessages/serializeApiInitialMessage';
-import { initialMessagesSchema } from '../../../../../lib/initialMessages/schema';
-import { updateInitialMessages } from '../../../../../lib/initialMessages/updateInitialMessages';
-import { getApiKey } from '../../../../../lib/apiKeys/getApiKey';
-export const buildGET = ({ prisma: providedPrisma } = {}) => async (_request, props) => {
-    const prisma = resolvePrisma(providedPrisma);
-    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: {
-            initialMessages: {
-                orderBy: {
-                    orderNumber: 'asc',
-                },
-            },
-        },
-    });
-    if (!assistant) {
-        return NextResponse.json({ error: 'No assistant found' }, { status: 400 });
-    }
-    return NextResponse.json({
-        initialMessages: assistant.initialMessages.map((m) => serializeApiInitialMessage({ initialMessage: m })),
-    }, { headers: cacheHeaders });
-};
-export const GET = ((...args) => buildGET()(...args));
-export const buildPUT = ({ prisma: providedPrisma } = {}) => async (request, props) => {
-    const prisma = resolvePrisma(providedPrisma);
-    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 bodyParse = initialMessagesSchema.safeParse(body);
-    if (!bodyParse.success) {
-        return NextResponse.json({ error: 'Invalid body' }, { status: 400 });
-    }
-    const { initialMessages } = bodyParse.data;
-    const assistant = await prisma.assistant.findFirst({
-        where: {
-            id: assistantId,
-            workspaceId: privateApiKey.workspaceId,
-        },
-    });
-    if (!assistant) {
-        return NextResponse.json({ error: 'No assistant found' }, { status: 400 });
-    }
-    const messages = await updateInitialMessages({
-        assistantId: assistant.id,
-        initialMessages,
-        prisma,
-    });
-    return NextResponse.json({
-        initialMessages: messages.map((m) => serializeApiInitialMessage({ initialMessage: m })),
-    }, { headers: cacheHeaders });
-};
-export const PUT = ((...args) => buildPUT()(...args));
-export const OPTIONS = () => NextResponse.json({}, {
-    headers: cacheHeaders,
-});
+import { prisma } from '../../../../../lib/prisma';
+import { buildGET, buildOPTIONS, buildPUT, } from './buildRoute';
+export const GET = buildGET({ prisma });
+export const PUT = buildPUT({ prisma });
+export const OPTIONS = buildOPTIONS();

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

@@ -0,0 +1,89 @@
+import { type PrismaClient } from '@prisma/client';
+import { NextResponse, type NextRequest } from 'next/server';
+type RouteProps = {
+    params: Promise<{
+        assistantId: string;
+        mcpServerId: string;
+    }>;
+};
+export declare const buildGET: ({ 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 buildPATCH: ({ 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 buildDELETE: ({ 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/[mcpServerId]/buildRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildRoute.d.ts","sourceRoot":"","sources":["../../../../../../../src/app/api/assistants/[assistantId]/mcp-servers/[mcpServerId]/buildRoute.ts"],"names":[],"mappings":"AACA,OAAO,EAA6B,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC7E,OAAO,EAAE,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,aAAa,CAAA;AAO5D,KAAK,UAAU,GAAG;IAChB,MAAM,EAAE,OAAO,CAAC;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAC9D,CAAA;AA0BD,eAAO,MAAM,QAAQ,GAClB,YAAY;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE,MAC9B,UAAU,WAAW,EAAE,OAAO,UAAU;;;;;;;;;;;;;;;;;;;;;;;GAoD9C,CAAA;AAEH,eAAO,MAAM,UAAU,GACpB,YAAY;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE,MAC9B,SAAS,WAAW,EAAE,OAAO,UAAU;;;;;;;;;;;;;;;;;;;;;;;GA2F7C,CAAA;AAEH,eAAO,MAAM,WAAW,GACrB,YAAY;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE,MAC9B,UAAU,WAAW,EAAE,OAAO,UAAU;;;;;;;;;;;;;;;;;;;;;;;GAwD9C,CAAA;AAEH,eAAO,MAAM,YAAY,8BAMtB,CAAA"}