@superinterface/server 1.6.0 → 1.7.0

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

@@ -25,53 +25,53 @@ declare const createAssistantSchema: z.ZodEffects<z.ZodObject<{
     }>>;
     truncationLastMessagesCount: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
 }, "strip", z.ZodTypeAny, {
-    instructions: string;
-    description: string;
-    modelProviderId: string;
     storageProviderType: "OPENAI" | "AZURE_OPENAI" | "SUPERINTERFACE_CLOUD" | "OPENAI_RESPONSES" | "AZURE_RESPONSES" | "AZURE_AGENTS";
+    modelProviderId: string;
     model: string;
+    description: string;
+    instructions: string;
     codeInterpreterEnabled: boolean;
     fileSearchEnabled: boolean;
+    storageProviderAssistantId?: string | null | undefined;
     name?: string | undefined;
     truncationType?: "AUTO" | "LAST_MESSAGES" | "DISABLED" | undefined;
     truncationLastMessagesCount?: number | null | undefined;
-    storageProviderAssistantId?: string | null | undefined;
 }, {
-    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;
-    truncationType?: "AUTO" | "LAST_MESSAGES" | "DISABLED" | undefined;
-    truncationLastMessagesCount?: number | null | undefined;
-    storageProviderAssistantId?: string | null | undefined;
+    instructions?: string | undefined;
     codeInterpreterEnabled?: boolean | undefined;
     fileSearchEnabled?: boolean | undefined;
+    truncationType?: "AUTO" | "LAST_MESSAGES" | "DISABLED" | undefined;
+    truncationLastMessagesCount?: number | null | undefined;
 }>, {
-    instructions: string;
-    description: string;
-    modelProviderId: string;
     storageProviderType: "OPENAI" | "AZURE_OPENAI" | "SUPERINTERFACE_CLOUD" | "OPENAI_RESPONSES" | "AZURE_RESPONSES" | "AZURE_AGENTS";
+    modelProviderId: string;
     model: string;
+    description: string;
+    instructions: string;
     codeInterpreterEnabled: boolean;
     fileSearchEnabled: boolean;
+    storageProviderAssistantId?: string | null | undefined;
     name?: string | undefined;
     truncationType?: "AUTO" | "LAST_MESSAGES" | "DISABLED" | undefined;
     truncationLastMessagesCount?: number | null | undefined;
-    storageProviderAssistantId?: string | null | undefined;
 }, {
-    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;
-    truncationType?: "AUTO" | "LAST_MESSAGES" | "DISABLED" | undefined;
-    truncationLastMessagesCount?: number | null | 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;

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,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyGtB,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

@@ -99,7 +99,9 @@ export const buildPOST = ({ prisma }) => async (request) => {
             ? { 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 })), (truncationType !== undefined && { truncationType })), (truncationLastMessagesCount !== undefined && { truncationLastMessagesCount })), { tools: {
+                : { openaiAssistantId: storageProviderAssistantId !== null && storageProviderAssistantId !== void 0 ? storageProviderAssistantId : null })), (truncationType !== undefined && { truncationType })), (truncationLastMessagesCount !== undefined && {
+            truncationLastMessagesCount,
+        })), { tools: {
                 create: [
                     ...(fileSearchEnabled
                         ? [

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"}

package/dist/lib/tools/isToolConfigAvailable.js

@@ -0,0 +1,111 @@
+import { ModelProviderType, StorageProviderType, ToolType, } from '@prisma/client';
+export const toolConfigs = [
+    {
+        type: ToolType.WEB_SEARCH,
+        availabilities: [
+            {
+                modelProviderType: ModelProviderType.ANTHROPIC,
+                storageProviderType: StorageProviderType.SUPERINTERFACE_CLOUD,
+            },
+            {
+                modelProviderType: ModelProviderType.OPENAI,
+                storageProviderType: StorageProviderType.OPENAI_RESPONSES,
+            },
+            {
+                modelProviderType: ModelProviderType.AZURE_OPENAI,
+                storageProviderType: StorageProviderType.AZURE_RESPONSES,
+            },
+        ],
+    },
+    {
+        type: ToolType.FILE_SEARCH,
+        availabilities: [
+            {
+                modelProviderType: ModelProviderType.OPENAI,
+                storageProviderType: StorageProviderType.OPENAI_RESPONSES,
+            },
+            {
+                modelProviderType: ModelProviderType.AZURE_OPENAI,
+                storageProviderType: StorageProviderType.AZURE_RESPONSES,
+            },
+            {
+                modelProviderType: ModelProviderType.OPENAI,
+                storageProviderType: StorageProviderType.OPENAI,
+            },
+            {
+                modelProviderType: ModelProviderType.AZURE_OPENAI,
+                storageProviderType: StorageProviderType.AZURE_OPENAI,
+            },
+            {
+                modelProviderType: ModelProviderType.AZURE_AI_PROJECT,
+                storageProviderType: StorageProviderType.AZURE_AGENTS,
+            },
+        ],
+    },
+    {
+        type: ToolType.IMAGE_GENERATION,
+        availabilities: [
+            {
+                modelProviderType: ModelProviderType.OPENAI,
+                storageProviderType: StorageProviderType.OPENAI_RESPONSES,
+            },
+            {
+                modelProviderType: ModelProviderType.AZURE_OPENAI,
+                storageProviderType: StorageProviderType.AZURE_RESPONSES,
+            },
+        ],
+    },
+    {
+        type: ToolType.COMPUTER_USE,
+        availabilities: [
+            {
+                modelProviderType: ModelProviderType.ANTHROPIC,
+                storageProviderType: StorageProviderType.SUPERINTERFACE_CLOUD,
+            },
+            {
+                modelProviderType: ModelProviderType.OPENAI,
+                storageProviderType: StorageProviderType.OPENAI_RESPONSES,
+            },
+            {
+                modelProviderType: ModelProviderType.AZURE_OPENAI,
+                storageProviderType: StorageProviderType.AZURE_RESPONSES,
+            },
+        ],
+    },
+    {
+        type: ToolType.CODE_INTERPRETER,
+        availabilities: [
+            {
+                modelProviderType: ModelProviderType.ANTHROPIC,
+                storageProviderType: StorageProviderType.SUPERINTERFACE_CLOUD,
+            },
+            {
+                modelProviderType: ModelProviderType.OPENAI,
+                storageProviderType: StorageProviderType.OPENAI_RESPONSES,
+            },
+            {
+                modelProviderType: ModelProviderType.AZURE_OPENAI,
+                storageProviderType: StorageProviderType.AZURE_RESPONSES,
+            },
+            {
+                modelProviderType: ModelProviderType.OPENAI,
+                storageProviderType: StorageProviderType.OPENAI,
+            },
+            {
+                modelProviderType: ModelProviderType.AZURE_OPENAI,
+                storageProviderType: StorageProviderType.AZURE_OPENAI,
+            },
+            {
+                modelProviderType: ModelProviderType.AZURE_AI_PROJECT,
+                storageProviderType: StorageProviderType.AZURE_AGENTS,
+            },
+        ],
+    },
+];
+export const isToolConfigAvailable = ({ toolType, modelProviderType, storageProviderType, }) => {
+    const toolConfig = toolConfigs.find((config) => config.type === toolType);
+    if (!toolConfig)
+        return false;
+    return toolConfig.availabilities.some((availability) => availability.modelProviderType === modelProviderType &&
+        availability.storageProviderType === storageProviderType);
+};

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

@@ -0,0 +1,39 @@
+import { Prisma } from '@prisma/client';
+export declare const toolInclude: {
+    readonly fileSearchTool: true;
+    readonly webSearchTool: true;
+    readonly codeInterpreterTool: true;
+    readonly imageGenerationTool: true;
+    readonly computerUseTool: true;
+};
+export declare const serializeApiTool: ({ tool, }: {
+    tool: Prisma.ToolGetPayload<{
+        include: typeof toolInclude;
+    }>;
+}) => {
+    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;
+};
+//# sourceMappingURL=serializeApiTool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"serializeApiTool.d.ts","sourceRoot":"","sources":["../../../src/lib/tools/serializeApiTool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAEvC,eAAO,MAAM,WAAW;;;;;;CAMd,CAAA;AAEV,eAAO,MAAM,gBAAgB,GAAI,WAE9B;IACD,IAAI,EAAE,MAAM,CAAC,cAAc,CAAC;QAC1B,OAAO,EAAE,OAAO,WAAW,CAAA;KAC5B,CAAC,CAAA;CACH;;;;;;;;;;;;;;;;;;;;;;;;;CAqCC,CAAA"}

package/dist/lib/tools/serializeApiTool.js

@@ -0,0 +1,35 @@
+export const toolInclude = {
+    fileSearchTool: true,
+    webSearchTool: true,
+    codeInterpreterTool: true,
+    imageGenerationTool: true,
+    computerUseTool: true,
+};
+export const serializeApiTool = ({ tool, }) => (Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ id: tool.id, type: tool.type }, (tool.fileSearchTool
+    ? {
+        fileSearchTool: {
+            vectorStoreIds: tool.fileSearchTool.vectorStoreIds,
+            maxNumResults: tool.fileSearchTool.maxNumResults,
+        },
+    }
+    : {})), (tool.webSearchTool ? { webSearchTool: {} } : {})), (tool.codeInterpreterTool ? { codeInterpreterTool: {} } : {})), (tool.imageGenerationTool
+    ? {
+        imageGenerationTool: {
+            model: tool.imageGenerationTool.model,
+            quality: tool.imageGenerationTool.quality,
+            size: tool.imageGenerationTool.size,
+            outputFormat: tool.imageGenerationTool.outputFormat,
+            background: tool.imageGenerationTool.background,
+            partialImages: tool.imageGenerationTool.partialImages,
+        },
+    }
+    : {})), (tool.computerUseTool
+    ? {
+        computerUseTool: {
+            displayWidth: tool.computerUseTool.displayWidth,
+            displayHeight: tool.computerUseTool.displayHeight,
+            environment: tool.computerUseTool.environment,
+            mcpServerId: tool.computerUseTool.mcpServerId,
+        },
+    }
+    : {})), { createdAt: tool.createdAt.toISOString(), updatedAt: tool.updatedAt.toISOString() }));