@superinterface/server 1.5.1 → 1.7.0

package/dist/app/api/assistants/[assistantId]/tools/[toolId]/route.d.ts

@@ -0,0 +1,107 @@
+export declare const GET: (_request: import("next/server").NextRequest, props: {
+    params: Promise<{
+        assistantId: string;
+        toolId: string;
+    }>;
+}) => Promise<import("next/server").NextResponse<{
+    error: string;
+}> | import("next/server").NextResponse<{
+    tool: {
+        createdAt: string;
+        updatedAt: string;
+        computerUseTool?: {
+            displayWidth: number;
+            displayHeight: number;
+            environment: import("@prisma/client").$Enums.ComputerUseToolEnvironment;
+            mcpServerId: string | null;
+        } | undefined;
+        imageGenerationTool?: {
+            model: string;
+            quality: import("@prisma/client").$Enums.ImageGenerationToolQuality;
+            size: import("@prisma/client").$Enums.ImageGenerationToolSize;
+            outputFormat: import("@prisma/client").$Enums.ImageGenerationToolOutputFormat;
+            background: import("@prisma/client").$Enums.ImageGenerationToolBackground;
+            partialImages: number;
+        } | undefined;
+        codeInterpreterTool?: {} | undefined;
+        webSearchTool?: {} | undefined;
+        fileSearchTool?: {
+            vectorStoreIds: string[];
+            maxNumResults: number;
+        } | undefined;
+        id: string;
+        type: import("@prisma/client").$Enums.ToolType;
+    };
+}>>;
+export declare const PATCH: (request: import("next/server").NextRequest, props: {
+    params: Promise<{
+        assistantId: string;
+        toolId: string;
+    }>;
+}) => Promise<import("next/server").NextResponse<{
+    error: string;
+}> | import("next/server").NextResponse<{
+    tool: {
+        createdAt: string;
+        updatedAt: string;
+        computerUseTool?: {
+            displayWidth: number;
+            displayHeight: number;
+            environment: import("@prisma/client").$Enums.ComputerUseToolEnvironment;
+            mcpServerId: string | null;
+        } | undefined;
+        imageGenerationTool?: {
+            model: string;
+            quality: import("@prisma/client").$Enums.ImageGenerationToolQuality;
+            size: import("@prisma/client").$Enums.ImageGenerationToolSize;
+            outputFormat: import("@prisma/client").$Enums.ImageGenerationToolOutputFormat;
+            background: import("@prisma/client").$Enums.ImageGenerationToolBackground;
+            partialImages: number;
+        } | undefined;
+        codeInterpreterTool?: {} | undefined;
+        webSearchTool?: {} | undefined;
+        fileSearchTool?: {
+            vectorStoreIds: string[];
+            maxNumResults: number;
+        } | undefined;
+        id: string;
+        type: import("@prisma/client").$Enums.ToolType;
+    };
+}>>;
+export declare const DELETE: (_request: import("next/server").NextRequest, props: {
+    params: Promise<{
+        assistantId: string;
+        toolId: string;
+    }>;
+}) => Promise<import("next/server").NextResponse<{
+    error: string;
+}> | import("next/server").NextResponse<{
+    tool: {
+        createdAt: string;
+        updatedAt: string;
+        computerUseTool?: {
+            displayWidth: number;
+            displayHeight: number;
+            environment: import("@prisma/client").$Enums.ComputerUseToolEnvironment;
+            mcpServerId: string | null;
+        } | undefined;
+        imageGenerationTool?: {
+            model: string;
+            quality: import("@prisma/client").$Enums.ImageGenerationToolQuality;
+            size: import("@prisma/client").$Enums.ImageGenerationToolSize;
+            outputFormat: import("@prisma/client").$Enums.ImageGenerationToolOutputFormat;
+            background: import("@prisma/client").$Enums.ImageGenerationToolBackground;
+            partialImages: number;
+        } | undefined;
+        codeInterpreterTool?: {} | undefined;
+        webSearchTool?: {} | undefined;
+        fileSearchTool?: {
+            vectorStoreIds: string[];
+            maxNumResults: number;
+        } | undefined;
+        id: string;
+        type: import("@prisma/client").$Enums.ToolType;
+    };
+}>>;
+export declare const OPTIONS: () => import("next/server").NextResponse<{}>;
+//# sourceMappingURL=route.d.ts.map

package/dist/app/api/assistants/[assistantId]/tools/[toolId]/route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../../../src/app/api/assistants/[assistantId]/tools/[toolId]/route.ts"],"names":[],"mappings":"AAGA,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]/tools/[toolId]/route.js

@@ -0,0 +1,6 @@
+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]/tools/buildRoute.d.ts

@@ -0,0 +1,74 @@
+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<{
+    tools: {
+        createdAt: string;
+        updatedAt: string;
+        computerUseTool?: {
+            displayWidth: number;
+            displayHeight: number;
+            environment: import("@prisma/client").$Enums.ComputerUseToolEnvironment;
+            mcpServerId: string | null;
+        } | undefined;
+        imageGenerationTool?: {
+            model: string;
+            quality: import("@prisma/client").$Enums.ImageGenerationToolQuality;
+            size: import("@prisma/client").$Enums.ImageGenerationToolSize;
+            outputFormat: import("@prisma/client").$Enums.ImageGenerationToolOutputFormat;
+            background: import("@prisma/client").$Enums.ImageGenerationToolBackground;
+            partialImages: number;
+        } | undefined;
+        codeInterpreterTool?: {} | undefined;
+        webSearchTool?: {} | undefined;
+        fileSearchTool?: {
+            vectorStoreIds: string[];
+            maxNumResults: number;
+        } | undefined;
+        id: string;
+        type: import("@prisma/client").$Enums.ToolType;
+    }[];
+}>>;
+export declare const buildPOST: ({ prisma }: {
+    prisma: PrismaClient;
+}) => (request: NextRequest, props: RouteProps) => Promise<NextResponse<{
+    error: string;
+}> | NextResponse<{
+    tool: {
+        createdAt: string;
+        updatedAt: string;
+        computerUseTool?: {
+            displayWidth: number;
+            displayHeight: number;
+            environment: import("@prisma/client").$Enums.ComputerUseToolEnvironment;
+            mcpServerId: string | null;
+        } | undefined;
+        imageGenerationTool?: {
+            model: string;
+            quality: import("@prisma/client").$Enums.ImageGenerationToolQuality;
+            size: import("@prisma/client").$Enums.ImageGenerationToolSize;
+            outputFormat: import("@prisma/client").$Enums.ImageGenerationToolOutputFormat;
+            background: import("@prisma/client").$Enums.ImageGenerationToolBackground;
+            partialImages: number;
+        } | undefined;
+        codeInterpreterTool?: {} | undefined;
+        webSearchTool?: {} | undefined;
+        fileSearchTool?: {
+            vectorStoreIds: string[];
+            maxNumResults: number;
+        } | undefined;
+        id: string;
+        type: import("@prisma/client").$Enums.ToolType;
+    };
+}>>;
+export declare const buildOPTIONS: () => () => NextResponse<{}>;
+export {};
+//# sourceMappingURL=buildRoute.d.ts.map

package/dist/app/api/assistants/[assistantId]/tools/buildRoute.d.ts.map

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

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

@@ -0,0 +1,121 @@
+import { NextResponse } from 'next/server';
+import { ApiKeyType, ToolType } from '@prisma/client';
+import { headers } from 'next/headers';
+import { cacheHeaders } from '../../../../../lib/cache/cacheHeaders';
+import { getApiKey } from '../../../../../lib/apiKeys/getApiKey';
+import { serializeApiTool, toolInclude, } from '../../../../../lib/tools/serializeApiTool';
+import { toolSchema } from '../../../../../lib/tools/toolSchema';
+import { isToolConfigAvailable } from '../../../../../lib/tools/isToolConfigAvailable';
+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: {
+            tools: {
+                include: toolInclude,
+                orderBy: {
+                    createdAt: 'desc',
+                },
+            },
+        },
+    });
+    if (!assistant) {
+        return NextResponse.json({ error: 'No assistant found' }, { status: 400 });
+    }
+    return NextResponse.json({
+        tools: assistant.tools.map((tool) => serializeApiTool({ tool })),
+    }, { headers: cacheHeaders });
+};
+export const buildPOST = ({ prisma }) => async (request, props) => {
+    var _a, _b, _c;
+    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,
+        },
+        include: {
+            modelProvider: true,
+        },
+    });
+    if (!assistant) {
+        return NextResponse.json({ error: 'No assistant found' }, { status: 400 });
+    }
+    const body = await request.json();
+    const parsed = toolSchema.safeParse(body);
+    if (!parsed.success) {
+        console.error('Tool creation error:', parsed.error);
+        return NextResponse.json({ error: 'Invalid payload' }, { status: 400 });
+    }
+    const { type } = parsed.data;
+    if (!isToolConfigAvailable({
+        toolType: type,
+        modelProviderType: assistant.modelProvider.type,
+        storageProviderType: assistant.storageProviderType,
+    })) {
+        return NextResponse.json({
+            error: `Tool type ${type} is not available for this assistant's provider configuration`,
+        }, { status: 400 });
+    }
+    const typeSpecificCreate = {};
+    if (type === ToolType.FILE_SEARCH) {
+        typeSpecificCreate.fileSearchTool = {
+            create: (_a = parsed.data.fileSearchTool) !== null && _a !== void 0 ? _a : {},
+        };
+    }
+    else if (type === ToolType.WEB_SEARCH) {
+        typeSpecificCreate.webSearchTool = { create: {} };
+    }
+    else if (type === ToolType.CODE_INTERPRETER) {
+        typeSpecificCreate.codeInterpreterTool = { create: {} };
+    }
+    else if (type === ToolType.IMAGE_GENERATION) {
+        typeSpecificCreate.imageGenerationTool = {
+            create: (_b = parsed.data.imageGenerationTool) !== null && _b !== void 0 ? _b : {},
+        };
+    }
+    else if (type === ToolType.COMPUTER_USE) {
+        typeSpecificCreate.computerUseTool = {
+            create: (_c = parsed.data.computerUseTool) !== null && _c !== void 0 ? _c : {},
+        };
+    }
+    const tool = await prisma.tool.create({
+        data: Object.assign({ type, assistantId: assistant.id }, typeSpecificCreate),
+        include: toolInclude,
+    });
+    return NextResponse.json({
+        tool: serializeApiTool({ tool }),
+    }, { headers: cacheHeaders });
+};
+export const buildOPTIONS = () => () => NextResponse.json({}, {
+    headers: cacheHeaders,
+});

package/dist/app/api/assistants/[assistantId]/tools/route.d.ts

@@ -0,0 +1,70 @@
+export declare const GET: (_request: import("next/server").NextRequest, props: {
+    params: Promise<{
+        assistantId: string;
+    }>;
+}) => Promise<import("next/server").NextResponse<{
+    error: string;
+}> | import("next/server").NextResponse<{
+    tools: {
+        createdAt: string;
+        updatedAt: string;
+        computerUseTool?: {
+            displayWidth: number;
+            displayHeight: number;
+            environment: import("@prisma/client").$Enums.ComputerUseToolEnvironment;
+            mcpServerId: string | null;
+        } | undefined;
+        imageGenerationTool?: {
+            model: string;
+            quality: import("@prisma/client").$Enums.ImageGenerationToolQuality;
+            size: import("@prisma/client").$Enums.ImageGenerationToolSize;
+            outputFormat: import("@prisma/client").$Enums.ImageGenerationToolOutputFormat;
+            background: import("@prisma/client").$Enums.ImageGenerationToolBackground;
+            partialImages: number;
+        } | undefined;
+        codeInterpreterTool?: {} | undefined;
+        webSearchTool?: {} | undefined;
+        fileSearchTool?: {
+            vectorStoreIds: string[];
+            maxNumResults: number;
+        } | undefined;
+        id: string;
+        type: import("@prisma/client").$Enums.ToolType;
+    }[];
+}>>;
+export declare const POST: (request: import("next/server").NextRequest, props: {
+    params: Promise<{
+        assistantId: string;
+    }>;
+}) => Promise<import("next/server").NextResponse<{
+    error: string;
+}> | import("next/server").NextResponse<{
+    tool: {
+        createdAt: string;
+        updatedAt: string;
+        computerUseTool?: {
+            displayWidth: number;
+            displayHeight: number;
+            environment: import("@prisma/client").$Enums.ComputerUseToolEnvironment;
+            mcpServerId: string | null;
+        } | undefined;
+        imageGenerationTool?: {
+            model: string;
+            quality: import("@prisma/client").$Enums.ImageGenerationToolQuality;
+            size: import("@prisma/client").$Enums.ImageGenerationToolSize;
+            outputFormat: import("@prisma/client").$Enums.ImageGenerationToolOutputFormat;
+            background: import("@prisma/client").$Enums.ImageGenerationToolBackground;
+            partialImages: number;
+        } | undefined;
+        codeInterpreterTool?: {} | undefined;
+        webSearchTool?: {} | undefined;
+        fileSearchTool?: {
+            vectorStoreIds: string[];
+            maxNumResults: number;
+        } | undefined;
+        id: string;
+        type: import("@prisma/client").$Enums.ToolType;
+    };
+}>>;
+export declare const OPTIONS: () => import("next/server").NextResponse<{}>;
+//# sourceMappingURL=route.d.ts.map

package/dist/app/api/assistants/[assistantId]/tools/route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../../src/app/api/assistants/[assistantId]/tools/route.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAuB,CAAA;AAEvC,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAwB,CAAA;AAEzC,eAAO,MAAM,OAAO,8CAAiB,CAAA"}

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

@@ -0,0 +1,5 @@
+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/buildRoute.d.ts

@@ -18,46 +18,60 @@ declare const createAssistantSchema: z.ZodEffects<z.ZodObject<{
     instructions: z.ZodDefault<z.ZodOptional<z.ZodString>>;
     codeInterpreterEnabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     fileSearchEnabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    truncationType: z.ZodOptional<z.ZodNativeEnum<{
+        AUTO: "AUTO";
+        LAST_MESSAGES: "LAST_MESSAGES";
+        DISABLED: "DISABLED";
+    }>>;
+    truncationLastMessagesCount: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
 }, "strip", z.ZodTypeAny, {
+    storageProviderType: "OPENAI" | "AZURE_OPENAI" | "SUPERINTERFACE_CLOUD" | "OPENAI_RESPONSES" | "AZURE_RESPONSES" | "AZURE_AGENTS";
+    modelProviderId: string;
     model: string;
-    instructions: string;
     description: string;
-    modelProviderId: string;
-    storageProviderType: "OPENAI" | "AZURE_OPENAI" | "SUPERINTERFACE_CLOUD" | "OPENAI_RESPONSES" | "AZURE_RESPONSES" | "AZURE_AGENTS";
+    instructions: string;
     codeInterpreterEnabled: boolean;
     fileSearchEnabled: boolean;
-    name?: string | undefined;
     storageProviderAssistantId?: string | null | undefined;
+    name?: string | undefined;
+    truncationType?: "AUTO" | "LAST_MESSAGES" | "DISABLED" | undefined;
+    truncationLastMessagesCount?: number | null | undefined;
 }, {
-    model: string;
-    modelProviderId: string;
     storageProviderType: "OPENAI" | "AZURE_OPENAI" | "SUPERINTERFACE_CLOUD" | "OPENAI_RESPONSES" | "AZURE_RESPONSES" | "AZURE_AGENTS";
+    modelProviderId: string;
+    model: string;
+    storageProviderAssistantId?: string | null | undefined;
     name?: string | undefined;
-    instructions?: string | undefined;
     description?: string | undefined;
-    storageProviderAssistantId?: string | null | undefined;
+    instructions?: string | undefined;
     codeInterpreterEnabled?: boolean | undefined;
     fileSearchEnabled?: boolean | undefined;
+    truncationType?: "AUTO" | "LAST_MESSAGES" | "DISABLED" | undefined;
+    truncationLastMessagesCount?: number | null | undefined;
 }>, {
+    storageProviderType: "OPENAI" | "AZURE_OPENAI" | "SUPERINTERFACE_CLOUD" | "OPENAI_RESPONSES" | "AZURE_RESPONSES" | "AZURE_AGENTS";
+    modelProviderId: string;
     model: string;
-    instructions: string;
     description: string;
-    modelProviderId: string;
-    storageProviderType: "OPENAI" | "AZURE_OPENAI" | "SUPERINTERFACE_CLOUD" | "OPENAI_RESPONSES" | "AZURE_RESPONSES" | "AZURE_AGENTS";
+    instructions: string;
     codeInterpreterEnabled: boolean;
     fileSearchEnabled: boolean;
-    name?: string | undefined;
     storageProviderAssistantId?: string | null | undefined;
+    name?: string | undefined;
+    truncationType?: "AUTO" | "LAST_MESSAGES" | "DISABLED" | undefined;
+    truncationLastMessagesCount?: number | null | undefined;
 }, {
-    model: string;
-    modelProviderId: string;
     storageProviderType: "OPENAI" | "AZURE_OPENAI" | "SUPERINTERFACE_CLOUD" | "OPENAI_RESPONSES" | "AZURE_RESPONSES" | "AZURE_AGENTS";
+    modelProviderId: string;
+    model: string;
+    storageProviderAssistantId?: string | null | undefined;
     name?: string | undefined;
-    instructions?: string | undefined;
     description?: string | undefined;
-    storageProviderAssistantId?: string | null | undefined;
+    instructions?: string | undefined;
     codeInterpreterEnabled?: boolean | undefined;
     fileSearchEnabled?: boolean | undefined;
+    truncationType?: "AUTO" | "LAST_MESSAGES" | "DISABLED" | undefined;
+    truncationLastMessagesCount?: number | null | undefined;
 }>;
 export declare const buildGET: ({ prisma }: {
     prisma: PrismaClient;
@@ -75,6 +89,8 @@ export declare const buildGET: ({ prisma }: {
         instructions: string;
         codeInterpreterEnabled: boolean;
         fileSearchEnabled: boolean;
+        truncationType: import("@prisma/client").$Enums.TruncationType;
+        truncationLastMessagesCount: number | null;
         createdAt: string;
         updatedAt: string;
         avatar: {
@@ -104,6 +120,8 @@ export declare const buildPOST: ({ prisma }: {
         instructions: string;
         codeInterpreterEnabled: boolean;
         fileSearchEnabled: boolean;
+        truncationType: import("@prisma/client").$Enums.TruncationType;
+        truncationLastMessagesCount: number | null;
         createdAt: string;
         updatedAt: string;
         avatar: {

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

@@ -1 +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;;;;;;;;;;;;;;;;;;;;;;;;;;GAqGtB,CAAA;AAEH,eAAO,MAAM,YAAY,8BAMtB,CAAA;AAEH,OAAO,EAAE,qBAAqB,EAAE,CAAA"}
+{"version":3,"file":"buildRoute.d.ts","sourceRoot":"","sources":["../../../../src/app/api/assistants/buildRoute.ts"],"names":[],"mappings":"AACA,OAAO,EAKL,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsCvB,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2GtB,CAAA;AAEH,eAAO,MAAM,YAAY,8BAMtB,CAAA;AAEH,OAAO,EAAE,qBAAqB,EAAE,CAAA"}

package/dist/app/api/assistants/buildRoute.js

@@ -1,5 +1,5 @@
 import { headers } from 'next/headers';
-import { ApiKeyType, StorageProviderType, ToolType, } from '@prisma/client';
+import { ApiKeyType, StorageProviderType, TruncationType, ToolType, } from '@prisma/client';
 import { NextResponse } from 'next/server';
 import { z } from 'zod';
 import { cacheHeaders } from '../../../lib/cache/cacheHeaders';
@@ -16,6 +16,8 @@ const createAssistantSchema = z
     instructions: z.string().optional().default(''),
     codeInterpreterEnabled: z.boolean().optional().default(false),
     fileSearchEnabled: z.boolean().optional().default(false),
+    truncationType: z.nativeEnum(TruncationType).optional(),
+    truncationLastMessagesCount: z.number().int().nullable().optional(),
 })
     .superRefine((data, ctx) => {
     if (data.storageProviderType === StorageProviderType.SUPERINTERFACE_CLOUD &&
@@ -87,17 +89,19 @@ export const buildPOST = ({ prisma }) => async (request) => {
             error: `Missing required fields. ${JSON.stringify(parseResult.error.format())}`,
         }, { status: 400 });
     }
-    const { storageProviderType, storageProviderAssistantId, modelProviderId, model, name, description, instructions, codeInterpreterEnabled, fileSearchEnabled, } = parseResult.data;
+    const { storageProviderType, storageProviderAssistantId, modelProviderId, model, name, description, instructions, codeInterpreterEnabled, fileSearchEnabled, truncationType, truncationLastMessagesCount, } = parseResult.data;
     const workspaceId = privateApiKey.workspaceId;
     const assistant = await prisma.assistant.create({
-        data: Object.assign(Object.assign({ workspace: { connect: { id: workspaceId } }, modelProvider: { connect: { id: modelProviderId } }, modelSlug: model, name,
+        data: Object.assign(Object.assign(Object.assign(Object.assign({ workspace: { connect: { id: workspaceId } }, modelProvider: { connect: { id: modelProviderId } }, modelSlug: model, name,
             description,
             instructions,
             storageProviderType }, (storageProviderType === StorageProviderType.AZURE_AGENTS
             ? { azureAgentsAgentId: storageProviderAssistantId !== null && storageProviderAssistantId !== void 0 ? storageProviderAssistantId : null }
             : storageProviderType === StorageProviderType.AZURE_RESPONSES
                 ? { azureResponsesAgentName: storageProviderAssistantId !== null && storageProviderAssistantId !== void 0 ? storageProviderAssistantId : null }
-                : { openaiAssistantId: storageProviderAssistantId !== null && storageProviderAssistantId !== void 0 ? storageProviderAssistantId : null })), { tools: {
+                : { openaiAssistantId: storageProviderAssistantId !== null && storageProviderAssistantId !== void 0 ? storageProviderAssistantId : null })), (truncationType !== undefined && { truncationType })), (truncationLastMessagesCount !== undefined && {
+            truncationLastMessagesCount,
+        })), { tools: {
                 create: [
                     ...(fileSearchEnabled
                         ? [

package/dist/app/api/assistants/route.d.ts

@@ -14,6 +14,8 @@ export declare const GET: () => Promise<import("next/server").NextResponse<{
         instructions: string;
         codeInterpreterEnabled: boolean;
         fileSearchEnabled: boolean;
+        truncationType: import("@prisma/client").$Enums.TruncationType;
+        truncationLastMessagesCount: number | null;
         createdAt: string;
         updatedAt: string;
         avatar: {
@@ -41,6 +43,8 @@ export declare const POST: (request: Request) => Promise<import("next/server").N
         instructions: string;
         codeInterpreterEnabled: boolean;
         fileSearchEnabled: boolean;
+        truncationType: import("@prisma/client").$Enums.TruncationType;
+        truncationLastMessagesCount: number | null;
         createdAt: string;
         updatedAt: string;
         avatar: {

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

@@ -1 +1 @@
-{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../src/app/api/assistants/route.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,qBAAqB,EACtB,MAAM,cAAc,CAAA;AAErB,OAAO,EAAE,qBAAqB,EAAE,CAAA;AAEhC,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;GAAuB,CAAA;AAEvC,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;GAAwB,CAAA;AAEzC,eAAO,MAAM,OAAO,8CAAiB,CAAA"}
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../src/app/api/assistants/route.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,qBAAqB,EACtB,MAAM,cAAc,CAAA;AAErB,OAAO,EAAE,qBAAqB,EAAE,CAAA;AAEhC,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAuB,CAAA;AAEvC,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAwB,CAAA;AAEzC,eAAO,MAAM,OAAO,8CAAiB,CAAA"}

package/dist/lib/assistants/serializeApiAssistant.d.ts

@@ -22,6 +22,8 @@ export declare const serializeApiAssistant: ({ assistant, }: {
     instructions: string;
     codeInterpreterEnabled: boolean;
     fileSearchEnabled: boolean;
+    truncationType: import("@prisma/client").$Enums.TruncationType;
+    truncationLastMessagesCount: number | null;
     createdAt: string;
     updatedAt: string;
     avatar: {

package/dist/lib/assistants/serializeApiAssistant.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serializeApiAssistant.d.ts","sourceRoot":"","sources":["../../../src/lib/assistants/serializeApiAssistant.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAK5C,eAAO,MAAM,qBAAqB,GAAI,gBAEnC;IACD,SAAS,EAAE,MAAM,CAAC,mBAAmB,CAAC;QACpC,OAAO,EAAE;YACP,KAAK,EAAE,IAAI,CAAA;YACX,MAAM,EAAE;gBACN,OAAO,EAAE;oBACP,UAAU,EAAE,IAAI,CAAA;oBAChB,WAAW,EAAE,IAAI,CAAA;iBAClB,CAAA;aACF,CAAA;SACF,CAAA;KACF,CAAC,CAAA;CACH;;;;;;;;;;;;;;;;;;;;;;CAyBC,CAAA"}
+{"version":3,"file":"serializeApiAssistant.d.ts","sourceRoot":"","sources":["../../../src/lib/assistants/serializeApiAssistant.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAK5C,eAAO,MAAM,qBAAqB,GAAI,gBAEnC;IACD,SAAS,EAAE,MAAM,CAAC,mBAAmB,CAAC;QACpC,OAAO,EAAE;YACP,KAAK,EAAE,IAAI,CAAA;YACX,MAAM,EAAE;gBACN,OAAO,EAAE;oBACP,UAAU,EAAE,IAAI,CAAA;oBAChB,WAAW,EAAE,IAAI,CAAA;iBAClB,CAAA;aACF,CAAA;SACF,CAAA;KACF,CAAC,CAAA;CACH;;;;;;;;;;;;;;;;;;;;;;;;CA2BC,CAAA"}

package/dist/lib/assistants/serializeApiAssistant.js

@@ -18,6 +18,8 @@ export const serializeApiAssistant = ({ assistant, }) => {
         instructions: assistant.instructions,
         codeInterpreterEnabled: assistant.tools.some((tool) => tool.type === ToolType.CODE_INTERPRETER),
         fileSearchEnabled: assistant.tools.some((tool) => tool.type === ToolType.FILE_SEARCH),
+        truncationType: assistant.truncationType,
+        truncationLastMessagesCount: assistant.truncationLastMessagesCount,
         createdAt: assistant.createdAt.toISOString(),
         updatedAt: assistant.updatedAt.toISOString(),
         avatar: serializeAvatar({

package/dist/lib/tools/isToolConfigAvailable.d.ts

@@ -0,0 +1,16 @@
+import { ModelProviderType, StorageProviderType, ToolType } from '@prisma/client';
+export type ToolConfigAvailability = {
+    modelProviderType: ModelProviderType;
+    storageProviderType: StorageProviderType;
+};
+export type ToolConfig = {
+    type: ToolType;
+    availabilities: ToolConfigAvailability[];
+};
+export declare const toolConfigs: ToolConfig[];
+export declare const isToolConfigAvailable: ({ toolType, modelProviderType, storageProviderType, }: {
+    toolType: ToolType;
+    modelProviderType: ModelProviderType;
+    storageProviderType: StorageProviderType;
+}) => boolean;
+//# sourceMappingURL=isToolConfigAvailable.d.ts.map

package/dist/lib/tools/isToolConfigAvailable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isToolConfigAvailable.d.ts","sourceRoot":"","sources":["../../../src/lib/tools/isToolConfigAvailable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,QAAQ,EACT,MAAM,gBAAgB,CAAA;AAEvB,MAAM,MAAM,sBAAsB,GAAG;IACnC,iBAAiB,EAAE,iBAAiB,CAAA;IACpC,mBAAmB,EAAE,mBAAmB,CAAA;CACzC,CAAA;AAED,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,QAAQ,CAAA;IACd,cAAc,EAAE,sBAAsB,EAAE,CAAA;CACzC,CAAA;AAED,eAAO,MAAM,WAAW,EAAE,UAAU,EAsGnC,CAAA;AAED,eAAO,MAAM,qBAAqB,GAAI,uDAInC;IACD,QAAQ,EAAE,QAAQ,CAAA;IAClB,iBAAiB,EAAE,iBAAiB,CAAA;IACpC,mBAAmB,EAAE,mBAAmB,CAAA;CACzC,KAAG,OASH,CAAA"}