@superinterface/server 1.0.24 → 1.0.26

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

@@ -0,0 +1,85 @@
+import { headers } from 'next/headers';
+import { ApiKeyType } from '@prisma/client';
+import { NextResponse } from 'next/server';
+import { createTaskSchema } from '../../../lib/tasks/schemas';
+import { cacheHeaders } from '../../../lib/cache/cacheHeaders';
+import { serializeTask } from '../../../lib/tasks/serializeTask';
+import { validateSchedule } from '../../../lib/tasks/validateSchedule';
+import { getApiKey } from '../../../lib/apiKeys/getApiKey';
+import { scheduleTask } from '../../../lib/tasks/scheduleTask';
+export const buildGET = ({ prisma }) => async (request) => {
+    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 key = request.nextUrl.searchParams.get('key');
+    const tasks = await prisma.task.findMany({
+        where: Object.assign(Object.assign({}, (key ? { key } : {})), { thread: { assistant: { workspaceId: privateApiKey.workspaceId } } }),
+        orderBy: { createdAt: 'desc' },
+    });
+    return NextResponse.json({
+        tasks: tasks.map((t) => serializeTask({ task: t })),
+    }, { headers: cacheHeaders });
+};
+export const buildPOST = ({ prisma }) => async (request) => {
+    var _a;
+    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 parsed = createTaskSchema.safeParse(await request.json());
+    if (!parsed.success) {
+        return NextResponse.json({ error: 'Invalid payload' }, { status: 400 });
+    }
+    const { title, message, schedule, threadId } = parsed.data;
+    if (!validateSchedule(schedule)) {
+        return NextResponse.json({ error: 'Invalid schedule' }, { status: 400 });
+    }
+    const thread = await prisma.thread.findFirst({
+        where: {
+            id: threadId,
+            assistant: {
+                workspaceId: privateApiKey.workspaceId,
+            },
+        },
+    });
+    if (!thread) {
+        return NextResponse.json({ error: 'Thread not found' }, { status: 400 });
+    }
+    const task = await prisma.task.create({
+        data: {
+            title,
+            message,
+            schedule,
+            thread: {
+                connect: { id: thread.id },
+            },
+            key: (_a = parsed.data.key) !== null && _a !== void 0 ? _a : '',
+        },
+    });
+    await scheduleTask({ task, prisma });
+    return NextResponse.json({
+        task: serializeTask({ task }),
+    }, { headers: cacheHeaders });
+};
+export const buildOPTIONS = () => () => NextResponse.json({}, {
+    headers: cacheHeaders,
+});

package/dist/app/api/tasks/callback/buildRoute.d.ts

@@ -0,0 +1,6 @@
+import { type PrismaClient } from '@prisma/client';
+export declare const maxDuration = 800;
+export declare const buildPOST: ({ prisma }: {
+    prisma: PrismaClient;
+}) => (request: import("next/server").NextRequest | Request, params?: any) => Promise<Response>;
+//# sourceMappingURL=buildRoute.d.ts.map

package/dist/app/api/tasks/callback/buildRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildRoute.d.ts","sourceRoot":"","sources":["../../../../../src/app/api/tasks/callback/buildRoute.ts"],"names":[],"mappings":"AAGA,OAAO,EAIL,KAAK,YAAY,EAClB,MAAM,gBAAgB,CAAA;AAYvB,eAAO,MAAM,WAAW,MAAM,CAAA;AA+Q9B,eAAO,MAAM,SAAS,GAAI,YAAY;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE,8FAO7D,CAAA"}

package/dist/app/api/tasks/callback/buildRoute.js

@@ -0,0 +1,244 @@
+import { NextResponse } from 'next/server';
+import { verifySignatureAppRouter } from '@upstash/qstash/nextjs';
+import { createMessageResponse } from '@superinterface/react/server';
+import { LogRequestMethod, LogRequestRoute, LogLevel, } from '@prisma/client';
+import { assistantClientAdapter } from '../../../../lib/assistants/assistantClientAdapter';
+import { createRunOpts } from '../../../../lib/runs/createRunOpts';
+import { scheduleTask } from '../../../../lib/tasks/scheduleTask';
+import { handleToolCall } from '../../../../lib/toolCalls/handleToolCall';
+import { createLog } from '../../../../lib/logs/createLog';
+import { storageThreadId as getStorageThreadId } from '../../../../lib/threads/storageThreadId';
+import { redis } from '../../../../lib/redis';
+import { isOpenaiAssistantsStorageProvider } from '../../../../lib/storageProviders/isOpenaiAssistantsStorageProvider';
+import { managedOpenaiThreadId } from '../../../../lib/threads/managedOpenaiThreadId';
+import { serializeMetadata } from '../../../../lib/metadata/serializeMetadata';
+export const maxDuration = 800;
+const buildPostHandler = ({ prisma }) => async (request) => {
+    var _a, _b;
+    const { taskId } = await request.json();
+    const task = await prisma.task.findUnique({
+        where: { id: taskId },
+        include: {
+            thread: {
+                include: {
+                    assistant: {
+                        include: {
+                            modelProvider: true,
+                            tools: {
+                                include: {
+                                    fileSearchTool: true,
+                                    webSearchTool: true,
+                                    imageGenerationTool: true,
+                                    codeInterpreterTool: true,
+                                    computerUseTool: {
+                                        include: {
+                                            mcpServer: {
+                                                include: {
+                                                    stdioTransport: true,
+                                                    sseTransport: true,
+                                                    httpTransport: true,
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                            functions: {
+                                include: {
+                                    handler: {
+                                        include: {
+                                            requestHandler: true,
+                                            firecrawlHandler: true,
+                                            replicateHandler: true,
+                                            clientToolHandler: true,
+                                            assistantHandler: true,
+                                            createTaskHandler: true,
+                                            listTasksHandler: true,
+                                            updateTaskHandler: true,
+                                            deleteTaskHandler: true,
+                                        },
+                                    },
+                                },
+                            },
+                            mcpServers: {
+                                include: {
+                                    computerUseTool: true,
+                                    stdioTransport: true,
+                                    sseTransport: true,
+                                    httpTransport: true,
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    });
+    if (!task) {
+        return NextResponse.json({ error: 'Task not found' }, { status: 400 });
+    }
+    const assistant = task.thread.assistant;
+    const thread = task.thread;
+    const assistantClient = assistantClientAdapter({ assistant, prisma });
+    let storageThreadId;
+    try {
+        storageThreadId = getStorageThreadId({
+            thread,
+        });
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    }
+    catch (error) {
+        createLog({
+            log: {
+                requestMethod: LogRequestMethod.POST,
+                requestRoute: LogRequestRoute.MESSAGES,
+                level: LogLevel.ERROR,
+                status: 500,
+                message: 'Failed to get storage thread id.',
+                workspaceId: assistant.workspaceId,
+                assistantId: assistant.id,
+                threadId: thread.id,
+            },
+            prisma,
+        });
+        return NextResponse.json({ error: 'Failed to get storage thread id.' }, { status: 500 });
+    }
+    if (!storageThreadId &&
+        isOpenaiAssistantsStorageProvider({
+            storageProviderType: assistant.storageProviderType,
+        })) {
+        try {
+            storageThreadId = await managedOpenaiThreadId({
+                assistant,
+                threadId: thread.id,
+                prisma,
+            });
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        }
+        catch (error) {
+            createLog({
+                log: {
+                    requestMethod: LogRequestMethod.POST,
+                    requestRoute: LogRequestRoute.MESSAGES,
+                    level: LogLevel.ERROR,
+                    status: 500,
+                    message: `Failed to get managed openai thread id: ${error.message}`,
+                    workspaceId: assistant.workspaceId,
+                    assistantId: assistant.id,
+                    threadId: thread.id,
+                },
+                prisma,
+            });
+            return NextResponse.json({ error: 'Failed to get managed openai thread id.' }, { status: 500 });
+        }
+    }
+    if (!storageThreadId) {
+        createLog({
+            log: {
+                requestMethod: LogRequestMethod.POST,
+                requestRoute: LogRequestRoute.MESSAGES,
+                level: LogLevel.ERROR,
+                status: 500,
+                message: 'Invalid thread configuration.',
+                workspaceId: assistant.workspaceId,
+                assistantId: assistant.id,
+                threadId: thread.id,
+            },
+            prisma,
+        });
+        return NextResponse.json({ error: 'Invalid thread configuration.' }, { status: 500 });
+    }
+    try {
+        await assistantClient.beta.threads.messages.create(storageThreadId, {
+            role: 'user',
+            content: task.message,
+            metadata: serializeMetadata({
+                variables: {
+                    superinterfaceCreatedByType: 'TASK',
+                    superinterfaceCreatedById: task.id,
+                },
+                workspaceId: assistant.workspaceId,
+                prisma,
+            }),
+        });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }
+    catch (error) {
+        console.log({ error });
+        createLog({
+            log: {
+                requestMethod: LogRequestMethod.POST,
+                requestRoute: LogRequestRoute.MESSAGES,
+                level: LogLevel.ERROR,
+                status: 500,
+                message: `Failed to create message: ${error.message}`,
+                workspaceId: assistant.workspaceId,
+                assistantId: assistant.id,
+                threadId: thread.id,
+            },
+            prisma,
+        });
+        return NextResponse.json({ error: 'Failed to create message' }, { status: 500 });
+    }
+    let createRunStream;
+    try {
+        createRunStream = await assistantClient.beta.threads.runs.create(storageThreadId, await createRunOpts({ assistant, thread, prisma }));
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }
+    catch (error) {
+        console.log({ error });
+        createLog({
+            log: {
+                requestMethod: LogRequestMethod.POST,
+                requestRoute: LogRequestRoute.MESSAGES,
+                level: LogLevel.ERROR,
+                status: 500,
+                message: `Failed to create run stream: ${error.message}`,
+                workspaceId: assistant.workspaceId,
+                assistantId: assistant.id,
+                threadId: thread.id,
+            },
+            prisma,
+        });
+        return NextResponse.json({ error: 'Failed to create run stream' }, { status: 500 });
+    }
+    const messageResponse = createMessageResponse({
+        client: assistantClient,
+        createRunStream,
+        handleToolCall: handleToolCall({ assistant, thread, prisma }),
+    });
+    const decoder = new TextDecoder();
+    const reader = messageResponse.getReader();
+    while (true) {
+        const { value, done } = await reader.read();
+        if (done)
+            break;
+        if (!value)
+            continue;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let event;
+        try {
+            event = JSON.parse(decoder.decode(value));
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        }
+        catch (e) {
+            continue;
+        }
+        if (event.event === 'thread.run.requires_action' &&
+            ((_b = (_a = event.data) === null || _a === void 0 ? void 0 : _a.required_action) === null || _b === void 0 ? void 0 : _b.type) === 'submit_client_tool_outputs') {
+            const toolCalls = event.data.required_action.submit_client_tool_outputs.tool_calls;
+            if (Array.isArray(toolCalls)) {
+                await Promise.all(toolCalls.map((toolCall) => redis.set(`submit-client-tool-outputs:output:${toolCall.id}`, 'Client tools cannot be used during tasks', { ex: 60 * 60 * 24 * 7 })));
+            }
+        }
+    }
+    await scheduleTask({ task, prisma });
+    return NextResponse.json({ ok: true });
+};
+export const buildPOST = ({ prisma }) => {
+    const postHandler = buildPostHandler({ prisma });
+    return process.env.NODE_ENV === 'test' ||
+        !process.env.QSTASH_CURRENT_SIGNING_KEY
+        ? postHandler
+        : verifySignatureAppRouter(postHandler);
+};

package/dist/app/api/tasks/callback/route.d.ts

@@ -1,3 +1,4 @@
-export declare const maxDuration = 800;
+import { maxDuration } from './buildRoute';
+export { maxDuration };
 export declare const POST: (request: import("next/server").NextRequest | Request, params?: any) => Promise<Response>;
 //# sourceMappingURL=route.d.ts.map

package/dist/app/api/tasks/callback/route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../src/app/api/tasks/callback/route.ts"],"names":[],"mappings":"AAqBA,eAAO,MAAM,WAAW,MAAM,CAAA;AAgR9B,eAAO,MAAM,IAAI,2FAG0B,CAAA"}
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../src/app/api/tasks/callback/route.ts"],"names":[],"mappings":"AACA,OAAO,EAAa,WAAW,EAAE,MAAM,cAAc,CAAA;AAErD,OAAO,EAAE,WAAW,EAAE,CAAA;AAEtB,eAAO,MAAM,IAAI,2FAAwB,CAAA"}

package/dist/app/api/tasks/callback/route.js

@@ -1,244 +1,4 @@
-import { NextResponse } from 'next/server';
-import { verifySignatureAppRouter } from '@upstash/qstash/nextjs';
-import { createMessageResponse } from '@superinterface/react/server';
-import { LogRequestMethod, LogRequestRoute, LogLevel, } from '@prisma/client';
-import { resolvePrisma } from '../../../../lib/prisma';
-import { assistantClientAdapter } from '../../../../lib/assistants/assistantClientAdapter';
-import { createRunOpts } from '../../../../lib/runs/createRunOpts';
-import { scheduleTask } from '../../../../lib/tasks/scheduleTask';
-import { handleToolCall } from '../../../../lib/toolCalls/handleToolCall';
-import { createLog } from '../../../../lib/logs/createLog';
-import { storageThreadId as getStorageThreadId } from '../../../../lib/threads/storageThreadId';
-import { redis } from '../../../../lib/redis';
-import { isOpenaiAssistantsStorageProvider } from '../../../../lib/storageProviders/isOpenaiAssistantsStorageProvider';
-import { managedOpenaiThreadId } from '../../../../lib/threads/managedOpenaiThreadId';
-import { serializeMetadata } from '../../../../lib/metadata/serializeMetadata';
-export const maxDuration = 800;
-const buildPostHandler = ({ prisma: providedPrisma } = {}) => async (request) => {
-    var _a, _b;
-    const prisma = resolvePrisma(providedPrisma);
-    const { taskId } = await request.json();
-    const task = await prisma.task.findUnique({
-        where: { id: taskId },
-        include: {
-            thread: {
-                include: {
-                    assistant: {
-                        include: {
-                            modelProvider: true,
-                            tools: {
-                                include: {
-                                    fileSearchTool: true,
-                                    webSearchTool: true,
-                                    imageGenerationTool: true,
-                                    codeInterpreterTool: true,
-                                    computerUseTool: {
-                                        include: {
-                                            mcpServer: {
-                                                include: {
-                                                    stdioTransport: true,
-                                                    sseTransport: true,
-                                                    httpTransport: true,
-                                                },
-                                            },
-                                        },
-                                    },
-                                },
-                            },
-                            functions: {
-                                include: {
-                                    handler: {
-                                        include: {
-                                            requestHandler: true,
-                                            firecrawlHandler: true,
-                                            replicateHandler: true,
-                                            clientToolHandler: true,
-                                            assistantHandler: true,
-                                            createTaskHandler: true,
-                                            listTasksHandler: true,
-                                            updateTaskHandler: true,
-                                            deleteTaskHandler: true,
-                                        },
-                                    },
-                                },
-                            },
-                            mcpServers: {
-                                include: {
-                                    computerUseTool: true,
-                                    stdioTransport: true,
-                                    sseTransport: true,
-                                    httpTransport: true,
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        },
-    });
-    if (!task) {
-        return NextResponse.json({ error: 'Task not found' }, { status: 400 });
-    }
-    const assistant = task.thread.assistant;
-    const thread = task.thread;
-    const assistantClient = assistantClientAdapter({ assistant, prisma });
-    let storageThreadId;
-    try {
-        storageThreadId = getStorageThreadId({
-            thread,
-        });
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    }
-    catch (error) {
-        createLog({
-            log: {
-                requestMethod: LogRequestMethod.POST,
-                requestRoute: LogRequestRoute.MESSAGES,
-                level: LogLevel.ERROR,
-                status: 500,
-                message: 'Failed to get storage thread id.',
-                workspaceId: assistant.workspaceId,
-                assistantId: assistant.id,
-                threadId: thread.id,
-            },
-            prisma,
-        });
-        return NextResponse.json({ error: 'Failed to get storage thread id.' }, { status: 500 });
-    }
-    if (!storageThreadId &&
-        isOpenaiAssistantsStorageProvider({
-            storageProviderType: assistant.storageProviderType,
-        })) {
-        try {
-            storageThreadId = await managedOpenaiThreadId({
-                assistant,
-                threadId: thread.id,
-                prisma,
-            });
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        }
-        catch (error) {
-            createLog({
-                log: {
-                    requestMethod: LogRequestMethod.POST,
-                    requestRoute: LogRequestRoute.MESSAGES,
-                    level: LogLevel.ERROR,
-                    status: 500,
-                    message: `Failed to get managed openai thread id: ${error.message}`,
-                    workspaceId: assistant.workspaceId,
-                    assistantId: assistant.id,
-                    threadId: thread.id,
-                },
-                prisma,
-            });
-            return NextResponse.json({ error: 'Failed to get managed openai thread id.' }, { status: 500 });
-        }
-    }
-    if (!storageThreadId) {
-        createLog({
-            log: {
-                requestMethod: LogRequestMethod.POST,
-                requestRoute: LogRequestRoute.MESSAGES,
-                level: LogLevel.ERROR,
-                status: 500,
-                message: 'Invalid thread configuration.',
-                workspaceId: assistant.workspaceId,
-                assistantId: assistant.id,
-                threadId: thread.id,
-            },
-            prisma,
-        });
-        return NextResponse.json({ error: 'Invalid thread configuration.' }, { status: 500 });
-    }
-    try {
-        await assistantClient.beta.threads.messages.create(storageThreadId, {
-            role: 'user',
-            content: task.message,
-            metadata: serializeMetadata({
-                variables: {
-                    superinterfaceCreatedByType: 'TASK',
-                    superinterfaceCreatedById: task.id,
-                },
-                workspaceId: assistant.workspaceId,
-                prisma,
-            }),
-        });
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    }
-    catch (error) {
-        console.log({ error });
-        createLog({
-            log: {
-                requestMethod: LogRequestMethod.POST,
-                requestRoute: LogRequestRoute.MESSAGES,
-                level: LogLevel.ERROR,
-                status: 500,
-                message: `Failed to create message: ${error.message}`,
-                workspaceId: assistant.workspaceId,
-                assistantId: assistant.id,
-                threadId: thread.id,
-            },
-            prisma,
-        });
-        return NextResponse.json({ error: 'Failed to create message' }, { status: 500 });
-    }
-    let createRunStream;
-    try {
-        createRunStream = await assistantClient.beta.threads.runs.create(storageThreadId, await createRunOpts({ assistant, thread, prisma }));
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    }
-    catch (error) {
-        console.log({ error });
-        createLog({
-            log: {
-                requestMethod: LogRequestMethod.POST,
-                requestRoute: LogRequestRoute.MESSAGES,
-                level: LogLevel.ERROR,
-                status: 500,
-                message: `Failed to create run stream: ${error.message}`,
-                workspaceId: assistant.workspaceId,
-                assistantId: assistant.id,
-                threadId: thread.id,
-            },
-            prisma,
-        });
-        return NextResponse.json({ error: 'Failed to create run stream' }, { status: 500 });
-    }
-    const messageResponse = createMessageResponse({
-        client: assistantClient,
-        createRunStream,
-        handleToolCall: handleToolCall({ assistant, thread, prisma }),
-    });
-    const decoder = new TextDecoder();
-    const reader = messageResponse.getReader();
-    while (true) {
-        const { value, done } = await reader.read();
-        if (done)
-            break;
-        if (!value)
-            continue;
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        let event;
-        try {
-            event = JSON.parse(decoder.decode(value));
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        }
-        catch (e) {
-            continue;
-        }
-        if (event.event === 'thread.run.requires_action' &&
-            ((_b = (_a = event.data) === null || _a === void 0 ? void 0 : _a.required_action) === null || _b === void 0 ? void 0 : _b.type) === 'submit_client_tool_outputs') {
-            await Promise.all(event.data.required_action.submit_client_tool_outputs.tool_calls.map(
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            async (toolCall) => {
-                await redis.set(`submit-client-tool-outputs:output:${toolCall.id}`, 'Client tools cannot be used during tasks', { ex: 60 * 60 * 24 * 7 });
-            }));
-        }
-    }
-    await scheduleTask({ task, prisma });
-    return NextResponse.json({ ok: true });
-};
-const postHandler = buildPostHandler();
-export const POST = process.env.NODE_ENV === 'test' || !process.env.QSTASH_CURRENT_SIGNING_KEY
-    ? postHandler
-    : verifySignatureAppRouter(postHandler);
+import { prisma } from '../../../../lib/prisma';
+import { buildPOST, maxDuration } from './buildRoute';
+export { maxDuration };
+export const POST = buildPOST({ prisma });

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

@@ -1,10 +1,6 @@
-import { type PrismaClient } from '@prisma/client';
-import { NextResponse, type NextRequest } from 'next/server';
-export declare const buildGET: ({ prisma: providedPrisma }?: {
-    prisma?: PrismaClient;
-}) => (request: NextRequest) => Promise<NextResponse<{
+export declare const GET: (request: import("next/server").NextRequest) => Promise<import("next/server").NextResponse<{
     error: string;
-}> | NextResponse<{
+}> | import("next/server").NextResponse<{
     tasks: {
         id: string;
         title: string;
@@ -16,12 +12,9 @@ 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) => Promise<NextResponse<{
+export declare const POST: (request: import("next/server").NextRequest) => Promise<import("next/server").NextResponse<{
     error: string;
-}> | NextResponse<{
+}> | import("next/server").NextResponse<{
     task: {
         id: string;
         title: string;
@@ -33,6 +26,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/tasks/route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../src/app/api/tasks/route.ts"],"names":[],"mappings":"AACA,OAAO,EAAc,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC9D,OAAO,EAAE,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,aAAa,CAAA;AAS5D,eAAO,MAAM,QAAQ,GAClB,6BAA4B;IAAE,MAAM,CAAC,EAAE,YAAY,CAAA;CAAO,MACpD,SAAS,WAAW;;;;;;;;;;;;;GAqC1B,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,MACpD,SAAS,WAAW;;;;;;;;;;;;;GAkE1B,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/tasks/route.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,GAAG;;;;;;;;;;;;;GAAuB,CAAA;AAEvC,eAAO,MAAM,IAAI;;;;;;;;;;;;;GAAwB,CAAA;AAEzC,eAAO,MAAM,OAAO,8CAAiB,CAAA"}