Make report generation asynchronous using a job queue

app/actions.tsx

@@ -15,6 +15,9 @@ import { FollowupPanel } from '@/components/followup-panel'
 import { inquire, researcher, taskManager, querySuggestor, resolutionSearch, type DrawnFeature } from '@/lib/agents'
 import { writer } from '@/lib/agents/writer'
 import { saveChat, getSystemPrompt, generateReportContext } from '@/lib/actions/chat'
+import { enqueueJob } from '@/lib/actions/jobs'
+import { getCurrentUserIdOnServer } from '@/lib/auth/get-current-user'
+import { send } from '@vercel/queue'
 import { Chat, AIMessage } from '@/lib/types'
 import { UserMessage } from '@/components/user-message'
 import { BotMessage } from '@/components/message'
@@ -57,9 +60,23 @@ async function submit(formData?: FormData, skip?: boolean) {
  }
  try {
  const messages = JSON.parse(messagesString) as AIMessage[];
- return await generateReportContext(messages);
+ const userId = await getCurrentUserIdOnServer() || 'anonymous';
+
+ // Enqueue job for asynchronous processing
+ const jobId = await enqueueJob(userId, 'generate_report_context', { messages });
+
+ // Send to Vercel Queue
+ try {
+ await send('report-generation', { jobId });
+ } catch (queueError) {
+ console.error('Failed to send to Vercel Queue:', queueError);
+ // We continue because the worker might still poll if it's running,
+ // but ideally Vercel Queue handles the trigger.
+ }
+
+ return { jobId, status: 'processing' };
  } catch (e) {
- console.error('Failed to parse messages for report context:', e);
+ console.error('Failed to enqueue report context job:', e);
  return { title: 'QCX Intelligence Analysis', summary: 'Automated executive summary is currently unavailable.' };
  }
  }

app/api/queue/route.ts

@@ -0,0 +1,43 @@
+import { handleCallback } from '@vercel/queue';
+import { generateReportContext } from '@/lib/actions/chat';
+import { updateJob, getJob } from '@/lib/actions/jobs';
+import { NextRequest } from 'next/server';
+
+const queueHandler = handleCallback(async (payload: any) => {
+ const { jobId } = payload;
+ if (!jobId) {
+ console.error('No jobId in queue payload');
+ return;
+ }
+
+ try {
+ const job = await getJob(jobId);
+ if (!job) {
+ console.error(`Job ${jobId} not found`);
+ return;
+ }
+
+ await updateJob(jobId, { status: 'processing' });
+
+ const { messages } = job.payload as { messages: any[] };
+ const result = await generateReportContext(messages);
+
+ await updateJob(jobId, {
+ status: 'completed',
+ result,
+ updatedAt: new Date(),
+ });
+ console.log(`Job ${jobId} completed via Vercel Queue`);
+ } catch (error) {
+ console.error(`Job ${jobId} failed in Vercel Queue:`, error);
+ await updateJob(jobId, {
+ status: 'failed',
+ error: error instanceof Error ? error.message : String(error),
+ updatedAt: new Date(),
+ });
+ }
+});
+
+export async function POST(request: NextRequest) {
+ return queueHandler(request);
+}

components/download-report-button.tsx

@@ -11,6 +11,7 @@ import { AI } from '@/app/actions'
 import { useActions } from 'ai/rsc'
 import { toast } from 'sonner'
 import { ReportTemplate } from './report-template'
+import { getJobStatus } from '@/lib/actions/jobs-client'
 import { createPortal } from 'react-dom'
 
 export const DownloadReportButton = () => {
@@ -57,7 +58,34 @@ export const DownloadReportButton = () => {
  formData.append('action', 'generate_report_context');
  formData.append('messages', JSON.stringify(aiState.messages));
 
- const { title, summary } = await (actions as any).submit(formData);
+ const { jobId } = await (actions as any).submit(formData);
+
+ if (!jobId) {
+ throw new Error('Failed to start report generation job');
+ }
+
+ // Polling for job completion
+ let jobResult = null;
+ let attempts = 0;
+ const maxAttempts = 60; // 60 seconds
+
+ while (attempts < maxAttempts) {
+ const { status, result, error } = await getJobStatus(jobId);
+ if (status === 'completed') {
+ jobResult = result;
+ break;
+ } else if (status === 'failed') {
+ throw new Error(error || 'Job failed');
+ }
+ attempts++;
+ await new Promise(resolve => setTimeout(resolve, 1000));
+ }
+
+ if (!jobResult) {
+ throw new Error('Report generation timed out');
+ }
+
+ const { title, summary } = jobResult as { title: string, summary: string };
 
  const finalTitle = title || 'QCX Intelligence Analysis'
  setReportTitle(finalTitle)

lib/actions/jobs-client.ts

@@ -0,0 +1,7 @@
+'use server'
+
+import { getJobStatus as getJobStatusServer } from './jobs'
+
+export async function getJobStatus(jobId: string) {
+ return await getJobStatusServer(jobId)
+}

lib/actions/jobs.ts

@@ -0,0 +1,54 @@
+'use server'
+
+import { db } from '@/lib/db'
+import { jobs } from '@/lib/db/schema'
+import { eq } from 'drizzle-orm'
+import { revalidatePath } from 'next/cache'
+
+export async function enqueueJob(userId: string, type: string, payload: any) {
+ try {
+ const result = await db.insert(jobs).values({
+ userId,
+ type,
+ payload,
+ status: 'pending',
+ }).returning({ id: jobs.id })
+
+ return result[0].id
+ } catch (error) {
+ console.error('Error enqueuing job:', error)
+ throw error
+ }
+}
+
+export async function getJob(jobId: string) {
+ try {
+ const result = await db.select().from(jobs).where(eq(jobs.id, jobId)).limit(1)
+ return result[0] || null
+ } catch (error) {
+ console.error('Error getting job:', error)
+ return null
+ }
+}
+
+export async function updateJob(jobId: string, updates: Partial<typeof jobs.$inferInsert>) {
+ try {
+ await db.update(jobs)
+ .set({ ...updates, updatedAt: new Date() })
+ .where(eq(jobs.id, jobId))
+ } catch (error) {
+ console.error('Error updating job:', error)
+ throw error
+ }
+}
+
+export async function getJobStatus(jobId: string) {
+ 'use server'
+ const job = await getJob(jobId)
+ if (!job) return { status: 'not_found' }
+ return {
+ status: job.status,
+ result: job.result,
+ error: job.error
+ }
+}

lib/db/schema.ts

@@ -102,6 +102,18 @@ export const calendarNotes = pgTable('calendar_notes', {
  updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),
 });
 
+export const jobs = pgTable('jobs', {
+ id: uuid('id').primaryKey().defaultRandom(),
+ userId: uuid('user_id').notNull().references(() => users.id, { onDelete: 'cascade' }),
+ type: text('type').notNull(),
+ status: text('status').notNull().default('pending'),
+ payload: jsonb('payload'),
+ result: jsonb('result'),
+ error: text('error'),
+ createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+ updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),
+});
+
 // Relations
 export const usersRelations = relations(users, ({ many }) => ({
  chats: many(chats),
@@ -111,6 +123,14 @@ export const usersRelations = relations(users, ({ many }) => ({
  systemPrompts: many(systemPrompts),
  locations: many(locations),
  visualizations: many(visualizations),
+ jobs: many(jobs),
+}));
+
+export const jobsRelations = relations(jobs, ({ one }) => ({
+ user: one(users, {
+ fields: [jobs.userId],
+ references: [users.id],
+ }),
 }));
 
 export const chatsRelations = relations(chats, ({ one, many }) => ({