@superinterface/server 1.0.25 → 1.0.26

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

@@ -1,120 +1,5 @@
-import { NextResponse } from 'next/server';
-import { ApiKeyType, TransportType } 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 { 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 } = 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 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 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 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]/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<{
     assistant: {
         id: string;
         storageProviderType: import("@prisma/client").$Enums.StorageProviderType;
@@ -32,7 +28,7 @@ export declare const buildGET: ({ prisma: providedPrisma }?: {
             } | null;
         };
     };
-}> | NextResponse<{
+}> | import("next/server").NextResponse<{
     assistant: {
         id: string;
         name: string;
@@ -56,16 +52,13 @@ export declare const buildGET: ({ prisma: providedPrisma }?: {
         };
     };
 }>>;
-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;
     }>;
-}) => Promise<NextResponse<{
+}) => Promise<import("next/server").NextResponse<{
     error: string;
-}> | NextResponse<{
+}> | import("next/server").NextResponse<{
     assistant: {
         id: string;
         storageProviderType: import("@prisma/client").$Enums.StorageProviderType;
@@ -90,16 +83,13 @@ export declare const buildPATCH: ({ prisma: providedPrisma }?: {
         };
     };
 }>>;
-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;
     }>;
-}) => Promise<NextResponse<{
+}) => Promise<import("next/server").NextResponse<{
     error: string;
-}> | NextResponse<{
+}> | import("next/server").NextResponse<{
     assistant: {
         id: string;
         storageProviderType: import("@prisma/client").$Enums.StorageProviderType;
@@ -124,6 +114,5 @@ export declare const buildDELETE: ({ prisma: providedPrisma }?: {
         };
     };
 }>>;
-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]/route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../src/app/api/assistants/[assistantId]/route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC5D,OAAO,EAKL,KAAK,YAAY,EAClB,MAAM,gBAAgB,CAAA;AAUvB,eAAO,MAAM,QAAQ,GAClB,6BAA4B;IAAE,MAAM,CAAC,EAAE,YAAY,CAAA;CAAO,MAEzD,SAAS,WAAW,EACpB,OAAO;IACL,MAAM,EAAE,OAAO,CAAC;QACd,WAAW,EAAE,MAAM,CAAA;KACpB,CAAC,CAAA;CACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6FF,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;QACd,WAAW,EAAE,MAAM,CAAA;KACpB,CAAC,CAAA;CACH;;;;;;;;;;;;;;;;;;;;;;;;;;GAuJF,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,SAAS,WAAW,EACpB,OAAO;IACL,MAAM,EAAE,OAAO,CAAC;QACd,WAAW,EAAE,MAAM,CAAA;KACpB,CAAC,CAAA;CACH;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDF,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]/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]/route.js

@@ -1,233 +1,6 @@
-import { NextResponse } from 'next/server';
-import { StorageProviderType, ApiKeyType, ToolType, } from '@prisma/client';
-import { cacheHeaders } from '../../../../lib/cache/cacheHeaders';
-import { workspaceAccessWhere as getWorkspaceAccessWhere } from '../../../../lib/apiKeys/workspaceAccessWhere';
-import { resolvePrisma } from '../../../../lib/prisma';
-import { serializeAssistant } from '../../../../lib/assistants/serializeAssistant';
-import { serializeApiAssistant } from '../../../../lib/assistants/serializeApiAssistant';
-import { headers } from 'next/headers';
-import { z } from 'zod';
-import { getApiKey } from '../../../../lib/apiKeys/getApiKey';
-export const buildGET = ({ prisma: providedPrisma } = {}) => async (request, props) => {
-    const prisma = resolvePrisma(providedPrisma);
-    const params = await props.params;
-    const { assistantId } = params;
-    const headersList = await headers();
-    const authorization = headersList.get('authorization');
-    if (authorization) {
-        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.findUnique({
-            where: {
-                id: assistantId,
-                workspaceId: privateApiKey.workspaceId,
-            },
-            include: {
-                tools: true,
-                avatar: {
-                    include: {
-                        imageAvatar: true,
-                        iconAvatar: true,
-                    },
-                },
-            },
-        });
-        if (!assistant) {
-            return NextResponse.json({ error: 'No assistant found' }, { status: 400 });
-        }
-        return NextResponse.json({
-            assistant: serializeApiAssistant({ assistant }),
-        }, { headers: cacheHeaders });
-    }
-    const workspaceAccessWhere = await getWorkspaceAccessWhere({
-        publicApiKey: request.nextUrl.searchParams.get('publicApiKey'),
-        prisma,
-    });
-    if (!workspaceAccessWhere) {
-        return NextResponse.json({ error: 'Invalid api key' }, { status: 400 });
-    }
-    if (!assistantId) {
-        return NextResponse.json({ error: 'No assistant id found' }, { status: 400 });
-    }
-    const assistant = await prisma.assistant.findFirst({
-        where: {
-            id: assistantId,
-            workspace: workspaceAccessWhere,
-        },
-        include: {
-            avatar: {
-                include: {
-                    imageAvatar: true,
-                    iconAvatar: true,
-                },
-            },
-        },
-    });
-    if (!assistant) {
-        return NextResponse.json({ error: 'No assistant found' }, { status: 400 });
-    }
-    return NextResponse.json({
-        assistant: serializeAssistant({ assistant }),
-    }, { headers: cacheHeaders });
-};
-export const GET = ((...args) => buildGET()(...args));
-export const buildPATCH = ({ prisma: providedPrisma } = {}) => async (request, props) => {
-    const prisma = resolvePrisma(providedPrisma);
-    const params = await props.params;
-    const { assistantId } = 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 updateSchema = z
-        .object({
-        storageProviderType: z.nativeEnum(StorageProviderType).optional(),
-        storageProviderAssistantId: z.string().nullable().optional(),
-        modelProviderId: z.string().optional(),
-        model: z.string().optional(),
-        name: z.string().optional(),
-        description: z.string().optional(),
-        instructions: z.string().optional(),
-        codeInterpreterEnabled: z.boolean().optional(),
-        fileSearchEnabled: z.boolean().optional(),
-    })
-        .superRefine((data, ctx) => {
-        if (!data.storageProviderType)
-            return;
-        if (data.storageProviderType ===
-            StorageProviderType.SUPERINTERFACE_CLOUD &&
-            data.storageProviderAssistantId) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: 'storageProviderAssistantId should not be provided for SUPERINTERFACE_CLOUD',
-                path: ['storageProviderAssistantId'],
-            });
-        }
-        if (data.storageProviderType !==
-            StorageProviderType.SUPERINTERFACE_CLOUD &&
-            !data.storageProviderAssistantId) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: 'storageProviderAssistantId is required for this storage provider',
-                path: ['storageProviderAssistantId'],
-            });
-        }
-    });
-    const parseResult = updateSchema.safeParse(await request.json());
-    if (!parseResult.success) {
-        return NextResponse.json({
-            error: 'Invalid body: ' + parseResult.error.message,
-        }, { status: 400 });
-    }
-    const { storageProviderType, storageProviderAssistantId, modelProviderId, model, name, description, instructions, codeInterpreterEnabled, fileSearchEnabled, } = parseResult.data;
-    const data = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (storageProviderType !== undefined && { storageProviderType })), (storageProviderAssistantId !== undefined && {
-        openaiAssistantId: storageProviderAssistantId,
-    })), (modelProviderId !== undefined && {
-        modelProvider: { connect: { id: modelProviderId } },
-    })), (model !== undefined && { modelSlug: model })), (name !== undefined && { name })), (description !== undefined && { description })), (instructions !== undefined && { instructions })), { tools: {
-            create: [
-                ...(codeInterpreterEnabled === true
-                    ? [
-                        {
-                            type: ToolType.CODE_INTERPRETER,
-                            codeInterpreterTool: { create: {} },
-                        },
-                    ]
-                    : []),
-                ...(fileSearchEnabled === true
-                    ? [{ type: ToolType.FILE_SEARCH, fileSearchTool: { create: {} } }]
-                    : []),
-            ],
-            deleteMany: [
-                ...(codeInterpreterEnabled === false
-                    ? [{ assistantId, type: ToolType.CODE_INTERPRETER }]
-                    : []),
-                ...(fileSearchEnabled === false
-                    ? [{ assistantId, type: ToolType.FILE_SEARCH }]
-                    : []),
-            ],
-        } });
-    const assistant = await prisma.assistant.update({
-        where: {
-            id: assistantId,
-            workspaceId: privateApiKey.workspaceId,
-        },
-        data,
-        include: {
-            tools: true,
-            avatar: {
-                include: {
-                    imageAvatar: true,
-                    iconAvatar: true,
-                },
-            },
-        },
-    });
-    return NextResponse.json({
-        assistant: serializeApiAssistant({ assistant }),
-    }, { headers: cacheHeaders });
-};
-export const PATCH = ((...args) => buildPATCH()(...args));
-export const buildDELETE = ({ prisma: providedPrisma } = {}) => async (request, props) => {
-    const prisma = resolvePrisma(providedPrisma);
-    const params = await props.params;
-    const { assistantId } = 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,
-        },
-        include: {
-            tools: true,
-            avatar: {
-                include: {
-                    imageAvatar: true,
-                    iconAvatar: true,
-                },
-            },
-        },
-    });
-    if (!assistant) {
-        return NextResponse.json({ error: 'No assistant found' }, { status: 400 });
-    }
-    await prisma.assistant.delete({
-        where: {
-            id: assistant.id,
-        },
-    });
-    return NextResponse.json({
-        assistant: serializeApiAssistant({ assistant }),
-    }, { 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/buildRoute.d.ts

@@ -0,0 +1,121 @@
+import { type PrismaClient } from '@prisma/client';
+import { NextResponse } from 'next/server';
+import { z } from 'zod';
+declare const createAssistantSchema: z.ZodEffects<z.ZodObject<{
+    storageProviderType: z.ZodNativeEnum<{
+        OPENAI: "OPENAI";
+        AZURE_OPENAI: "AZURE_OPENAI";
+        SUPERINTERFACE_CLOUD: "SUPERINTERFACE_CLOUD";
+        OPENAI_RESPONSES: "OPENAI_RESPONSES";
+        AZURE_OPENAI_RESPONSES: "AZURE_OPENAI_RESPONSES";
+    }>;
+    storageProviderAssistantId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    modelProviderId: z.ZodString;
+    model: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    instructions: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    codeInterpreterEnabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    fileSearchEnabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    model: string;
+    instructions: string;
+    description: string;
+    modelProviderId: string;
+    storageProviderType: "OPENAI" | "AZURE_OPENAI" | "SUPERINTERFACE_CLOUD" | "OPENAI_RESPONSES" | "AZURE_OPENAI_RESPONSES";
+    codeInterpreterEnabled: boolean;
+    fileSearchEnabled: boolean;
+    name?: string | undefined;
+    storageProviderAssistantId?: string | null | undefined;
+}, {
+    model: string;
+    modelProviderId: string;
+    storageProviderType: "OPENAI" | "AZURE_OPENAI" | "SUPERINTERFACE_CLOUD" | "OPENAI_RESPONSES" | "AZURE_OPENAI_RESPONSES";
+    name?: string | undefined;
+    instructions?: string | undefined;
+    description?: string | undefined;
+    storageProviderAssistantId?: string | null | undefined;
+    codeInterpreterEnabled?: boolean | undefined;
+    fileSearchEnabled?: boolean | undefined;
+}>, {
+    model: string;
+    instructions: string;
+    description: string;
+    modelProviderId: string;
+    storageProviderType: "OPENAI" | "AZURE_OPENAI" | "SUPERINTERFACE_CLOUD" | "OPENAI_RESPONSES" | "AZURE_OPENAI_RESPONSES";
+    codeInterpreterEnabled: boolean;
+    fileSearchEnabled: boolean;
+    name?: string | undefined;
+    storageProviderAssistantId?: string | null | undefined;
+}, {
+    model: string;
+    modelProviderId: string;
+    storageProviderType: "OPENAI" | "AZURE_OPENAI" | "SUPERINTERFACE_CLOUD" | "OPENAI_RESPONSES" | "AZURE_OPENAI_RESPONSES";
+    name?: string | undefined;
+    instructions?: string | undefined;
+    description?: string | undefined;
+    storageProviderAssistantId?: string | null | undefined;
+    codeInterpreterEnabled?: boolean | undefined;
+    fileSearchEnabled?: boolean | undefined;
+}>;
+export declare const buildGET: ({ prisma }: {
+    prisma: PrismaClient;
+}) => () => Promise<NextResponse<{
+    error: string;
+}> | NextResponse<{
+    assistants: {
+        id: string;
+        storageProviderType: import("@prisma/client").$Enums.StorageProviderType;
+        storageProviderAssistantId: string | null;
+        modelProviderId: string;
+        model: string;
+        name: string;
+        description: string;
+        instructions: string;
+        codeInterpreterEnabled: boolean;
+        fileSearchEnabled: boolean;
+        createdAt: string;
+        updatedAt: string;
+        avatar: {
+            type: import("@prisma/client").$Enums.AvatarType;
+            imageAvatar: {
+                url: string;
+            } | null;
+            iconAvatar: {
+                name: import("@prisma/client").$Enums.IconAvatarName;
+            } | null;
+        };
+    }[];
+}>>;
+export declare const buildPOST: ({ prisma }: {
+    prisma: PrismaClient;
+}) => (request: Request) => Promise<NextResponse<{
+    error: string;
+}> | NextResponse<{
+    assistant: {
+        id: string;
+        storageProviderType: import("@prisma/client").$Enums.StorageProviderType;
+        storageProviderAssistantId: string | null;
+        modelProviderId: string;
+        model: string;
+        name: string;
+        description: string;
+        instructions: string;
+        codeInterpreterEnabled: boolean;
+        fileSearchEnabled: boolean;
+        createdAt: string;
+        updatedAt: string;
+        avatar: {
+            type: import("@prisma/client").$Enums.AvatarType;
+            imageAvatar: {
+                url: string;
+            } | null;
+            iconAvatar: {
+                name: import("@prisma/client").$Enums.IconAvatarName;
+            } | null;
+        };
+    };
+}>>;
+export declare const buildOPTIONS: () => () => NextResponse<{}>;
+export { createAssistantSchema };
+//# sourceMappingURL=buildRoute.d.ts.map

package/dist/app/api/assistants/buildRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildRoute.d.ts","sourceRoot":"","sources":["../../../../src/app/api/assistants/buildRoute.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,KAAK,YAAY,EAClB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoCvB,CAAA;AAEJ,eAAO,MAAM,QAAQ,GAClB,YAAY;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CpC,CAAA;AAEH,eAAO,MAAM,SAAS,GACnB,YAAY;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE,MAC9B,SAAS,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;GAiGtB,CAAA;AAEH,eAAO,MAAM,YAAY,8BAMtB,CAAA;AAEH,OAAO,EAAE,qBAAqB,EAAE,CAAA"}