Resolution Search

[ngoiyaeric]

Sometimes the page refreshes or sometimes only the first one works and subsequent ones are not.
Here are the error logs
2026-06-26 12:19:14.558 [error] updateDrawingContext: Invalid or missing user ID.
2026-06-26 12:19:06.562 [info] Chat DB actions loaded. Ensure getCurrentUserId() is correctly implemented for server-side usage if applicable.
2026-06-26 12:19:06.567 [error] updateDrawingContext: Invalid or missing user ID.
2026-06-26 12:18:55.374 [info] File extraction: { exists: false, name: undefined, type: undefined, size: undefined }
2026-06-26 12:18:55.374 [info] Historical messages image filter: { filteredImagesCount: 0, retainedImagesCount: 1, totalMessages: 2 }
2026-06-26 12:18:55.374 [info] messageParts structure: { parts: [ { type: 'text', length: 94 } ], hasImage: false }
2026-06-26 12:18:55.374 [info] Final content structure: {
hasImage: false,
contentType: 'string',
isArray: false,
partsCount: 'N/A'
}
2026-06-26 12:18:55.374 [error] getSystemPrompt: Error: Error: Failed query: select "system_prompt" from "users" where "users"."id" = $1 limit $2
params: anonymous,1
at g.queryWithCache (.next/server/chunks/3278.js:48:15741)
at async (.next/server/chunks/3278.js:1:46409) {
query: 'select "system_prompt" from "users" where "users"."id" = $1 limit $2',
params: [Array],
[cause]: TypeError: Cannot read properties of undefined (reading 'searchParams')
at (.next/server/chunks/3278.js:1:46627)
at g.queryWithCache (.next/server/chunks/3278.js:48:15722)
at (.next/server/chunks/3278.js:1:46586)
at Object.startActiveSpan (.next/server/chunks/3278.js:48:41089)
}
2026-06-26 12:18:55.380 [error] onSetAIState: User not authenticated. Chat not saved.
2026-06-26 12:18:55.845 [error] Error [AI_APICallError]: Downloaded response does not contain a valid JPG, PNG, WebP, or ICO image.
at (.next/server/chunks/4234.js:50:5082)
at async tn (.next/server/chunks/4234.js:50:3937)
at async ty.doGenerate (.next/server/chunks/4234.js:50:11106)
at async fn (.next/server/chunks/5070.js:108:10911)
at async (.next/server/chunks/5070.js:104:6650)
at async I1 (.next/server/chunks/5070.js:104:4465)
at async fn (.next/server/chunks/5070.js:108:10298)
at async (.next/server/chunks/5070.js:104:6650)
at async l (.next/server/chunks/5225.js:142:7501) {
cause: undefined,
url: 'https://api.x.ai/v1/chat/completions',
requestBodyValues: [Object],
statusCode: 400,
responseHeaders: [Object],
responseBody: '{"code":"invalid-argument","error":"Downloaded response does not contain a valid JPG, PNG, WebP, or ICO image."}',
isRetryable: false,
data: [Object]
}
2026-06-26 12:18:55.846 [info] Researcher - Image pipeline trace: {
hasImage: true,
totalMessages: 3,
messagesWithImages: 1,
lastUserMessageContentStructure: { type: 'string', isArray: false, parts: 'string' }
}

2026-06-26 12:18:38.350 [info] File extraction: { exists: false, name: undefined, type: undefined, size: undefined }
2026-06-26 12:18:38.351 [info] Historical messages image filter: { filteredImagesCount: 0, retainedImagesCount: 1, totalMessages: 2 }
2026-06-26 12:18:38.351 [info] messageParts structure: { parts: [ { type: 'text', length: 109 } ], hasImage: false }
2026-06-26 12:18:38.351 [info] Final content structure: {
hasImage: false,
contentType: 'string',
isArray: false,
partsCount: 'N/A'
}
2026-06-26 12:18:38.359 [error] getSystemPrompt: Error: Error: Failed query: select "system_prompt" from "users" where "users"."id" = $1 limit $2
params: anonymous,1
at g.queryWithCache (.next/server/chunks/3278.js:48:15741)
at async (.next/server/chunks/3278.js:1:46409) {
query: 'select "system_prompt" from "users" where "users"."id" = $1 limit $2',
params: [Array],
[cause]: TypeError: Cannot read properties of undefined (reading 'searchParams')
at (.next/server/chunks/3278.js:1:46627)
at g.queryWithCache (.next/server/chunks/3278.js:48:15722)
at (.next/server/chunks/3278.js:1:46586)
at Object.startActiveSpan (.next/server/chunks/3278.js:48:41089)
}
2026-06-26 12:18:38.361 [error] onSetAIState: User not authenticated. Chat not saved.
2026-06-26 12:18:38.827 [error] Error [AI_APICallError]: Downloaded response does not contain a valid JPG, PNG, WebP, or ICO image.
at (.next/server/chunks/4234.js:50:5082)
at async tn (.next/server/chunks/4234.js:50:3937)
at async ty.doGenerate (.next/server/chunks/4234.js:50:11106)
at async fn (.next/server/chunks/5070.js:108:10911)
at async (.next/server/chunks/5070.js:104:6650)
at async I1 (.next/server/chunks/5070.js:104:4465)
at async fn (.next/server/chunks/5070.js:108:10298)
at async (.next/server/chunks/5070.js:104:6650)
at async l (.next/server/chunks/5225.js:142:7501) {
cause: undefined,
url: 'https://api.x.ai/v1/chat/completions',
requestBodyValues: [Object],
statusCode: 400,
responseHeaders: [Object],
responseBody: '{"code":"invalid-argument","error":"Downloaded response does not contain a valid JPG, PNG, WebP, or ICO image."}',
isRetryable: false,
data: [Object]
}
2026-06-26 12:18:38.828 [info] Researcher - Image pipeline trace: {
hasImage: true,
totalMessages: 3,
messagesWithImages: 1,
lastUserMessageContentStructure: { type: 'string', isArray: false, parts: 'string' }
}
2026-06-26 12:19:38.336 [error] Vercel Runtime Timeout Error: Task timed out after 60 seconds

[ngoiyaeric]

@coderabbitai plan to resolve this Based on the error logs and codebase analysis, you're experiencing authentication and database query failures that are causing page refreshes and preventing subsequent actions from working.

Root Cause Analysis

The primary issue is that the application is using 'anonymous' as a hardcoded user ID in app/actions.tsx line 491, but database operations expect valid UUIDs. This causes cascading failures across multiple systems. 1

Specific Issues

1. System Prompt Query Failure
The getSystemPrompt function in lib/actions/chat.ts is being called with 'anonymous' as the userId, which causes a database query to fail because 'anonymous' is not a valid UUID in the users table. 2

2. Drawing Context Update Failure
The updateDrawingContext function requires a valid user ID from getCurrentUserIdOnServer(), but when authentication fails, it returns an error "Invalid or missing user ID". 3

3. Chat Save Failure
The onSetAIState function checks for user authentication and fails to save chats when the user is not authenticated, logging "User not authenticated. Chat not saved." 4

4. Image Processing Error
The AI API (api.x.ai) is rejecting image data with "Downloaded response does not contain a valid JPG, PNG, WebP, or ICO image." This suggests the image pipeline is sending invalid image data to the API. 5

Recommended Fixes

1. Fix Anonymous User Handling
Replace the hardcoded 'anonymous' user ID in app/actions.tsx with proper authentication handling. Either:

• Implement a guest user system with valid UUIDs
• Skip database operations for unauthenticated users
• Require authentication before allowing chat operations

2. Add Null Checks
Add proper null checks before calling getSystemPrompt and other database operations that require valid user IDs. 6

3. Fix Image Pipeline
Investigate the image processing pipeline to ensure valid image data is being sent to the AI API. The logs show the image pipeline trace indicates hasImage: true but the content structure shows hasImage: false, suggesting a mismatch in image handling. 7

Notes

The Vercel timeout error (60 seconds) is likely a symptom of these authentication failures causing the application to hang while waiting for database operations that ultimately fail. The authentication system needs to be reviewed to ensure consistent user ID handling across all server actions and API routes. 8

Wiki pages you might want to explore:

• Chat History and Message Storage (QueueLab/QCX)

Citations

File: app/actions.tsx (L446-462)

  const hasImage = messageParts.some(part => part.type === 'image')
  console.log('messageParts structure:', {
    parts: messageParts.map(p => ({
      type: p.type,
      length: p.type === 'text' ? p.text.length : undefined
    })),
    hasImage
  })
  const content: CoreMessage['content'] = hasImage
    ? messageParts
    : messageParts.map(part => (part.type === 'text' ? part.text : '')).join('\n')
  console.log('Final content structure:', {
    hasImage,
    contentType: typeof content,
    isArray: Array.isArray(content),
    partsCount: Array.isArray(content) ? content.length : 'N/A'
  })

File: app/actions.tsx (L491-493)

  const userId = 'anonymous'
  const currentSystemPrompt = (await getSystemPrompt(userId)) || ''
  const mapProvider = formData?.get('mapProvider') as 'mapbox' | 'google'

File: app/actions.tsx (L689-750)

  onSetAIState: async ({ state }) => {
    'use server'

    if (!state.messages.some(e => e.type === 'response')) {
      return
    }

    const { chatId, messages } = state
    const createdAt = new Date()
    const path = `/search/${chatId}`

    let title = 'Untitled Chat'
    if (messages.length > 0) {
      const firstMessageContent = messages[0].content
      if (typeof firstMessageContent === 'string') {
        try {
          const parsedContent = JSON.parse(firstMessageContent)
          title = parsedContent.input?.substring(0, 100) || 'Untitled Chat'
        } catch (e) {
          title = firstMessageContent.substring(0, 100)
        }
      } else if (Array.isArray(firstMessageContent)) {
        const textPart = (
          firstMessageContent as { type: string; text?: string }[]
        ).find(p => p.type === 'text')
        title =
          textPart && textPart.text
            ? textPart.text.substring(0, 100)
            : 'Image Message'
      }
    }

    const updatedMessages: AIMessage[] = [
      ...messages,
      {
        id: nanoid(),
        role: 'assistant',
        content: `end`,
        type: 'end'
      }
    ]

    const { getCurrentUserIdOnServer } = await import(
      '@/lib/auth/get-current-user'
    )
    const actualUserId = await getCurrentUserIdOnServer()

    if (!actualUserId) {
      console.error('onSetAIState: User not authenticated. Chat not saved.')
      return
    }

    const chat: Chat = {
      id: chatId,
      createdAt,
      userId: actualUserId,
      path,
      title,
      messages: updatedMessages
    }
    await saveChat(chat, actualUserId)
  }

File: lib/actions/chat.ts (L186-211)

export async function updateDrawingContext(chatId: string, contextData: { drawnFeatures: any[], cameraState: any }) {
  const userId = await getCurrentUserIdOnServer();
  if (!userId) {
    console.error('updateDrawingContext: Could not get current user ID.');
    return { error: 'User not authenticated' };
  }

  const newDrawingMessage: DbNewMessage = {
    userId: userId,
    chatId: chatId,
    role: 'data',
    content: JSON.stringify(contextData),
    createdAt: new Date(),
  };

  try {
    const savedMessage = await dbCreateMessage(newDrawingMessage);
    if (!savedMessage) {
      throw new Error('Failed to save drawing context message.');
    }
    return { success: true, messageId: savedMessage.id };
  } catch (error) {
    console.error('updateDrawingContext: Error saving drawing context message:', error);
    return { error: 'Failed to save drawing context message' };
  }
}

File: lib/actions/chat.ts (L232-248)

export async function getSystemPrompt(
  userId: string
): Promise<string | null> {
  if (!userId) return null

  try {
    const result = await db.select({ systemPrompt: users.systemPrompt })
      .from(users)
      .where(eq(users.id, userId))
      .limit(1);

    return result[0]?.systemPrompt || null;
  } catch (error) {
    console.error('getSystemPrompt: Error:', error)
    return null
  }
}

File: lib/agents/researcher.tsx (L107-133)

  // Check if any message contains an image
  const hasImage = messages.some(message =>
    Array.isArray(message.content) &&
    message.content.some(part => part.type === 'image')
  )

  const lastUserMessage = [...messages].reverse().find(m => m.role === 'user')
  console.log('Researcher - Image pipeline trace:', {
    hasImage,
    totalMessages: messages.length,
    messagesWithImages: messages.filter(
      m =>
        Array.isArray(m.content) && m.content.some(p => p.type === 'image')
    ).length,
    lastUserMessageContentStructure: lastUserMessage
      ? {
          type: typeof lastUserMessage.content,
          isArray: Array.isArray(lastUserMessage.content),
          parts: Array.isArray(lastUserMessage.content)
            ? lastUserMessage.content.map(p => ({
                type: p.type,
                hasImage: p.type === 'image'
              }))
            : 'string'
        }
      : 'none'
  })

File: app/search/[id]/page.tsx (L29-35)

  const userId = await getCurrentUserIdOnServer();

  if (!userId) {
    // If no user, redirect to login or show appropriate page
    // For now, redirecting to home, but a login page would be better.
    redirect('/');
  }

[coderabbitai]

Coding Plan

Summary

• Fix the core "subsequent searches fail" bug by stripping the IMAGE_PROCESSED sentinel from message history so only genuine image data reaches the xAI vision API, with a defensive hasImage recomputation in the researcher.
• Eliminate the database crash and error-log noise by short-circuiting getSystemPrompt, updateDrawingContext, and the chat-save path for unauthenticated/"anonymous" users.
• Prevent the 60-second timeout/stall by wrapping agent streaming in error handling that finalizes the UI stream and surfaces a clean, client-visible error.

Design Choices

Design Choice 1: How should the `IMAGE_PROCESSED` sentinel be handled when preparing message history for the model?

Options Considered:

1. Strip IMAGE_PROCESSED image parts entirely from the messages sent to the model, while keeping the rest of the message content (text) intact.
2. Keep retaining the sentinel in the filter but recompute hasImage in the researcher so a vision model isn't selected, hoping the API ignores it.

Chosen Option: 1

Rationale: Option 1 — Stripping the sentinel before it reaches the model is the only reliable fix, since any image part sent to xAI must be a real data URL; recomputing hasImage alone still forwards the invalid part.

💡 User Tips

Regenerate the plan with different choices with @coderabbitai <feedback>.

Implementation Steps

Phase 1: Repair the Resolution Search Image Pipeline

This phase fixes the primary bug — why the first search works but subsequent ones fail. After a resolution search, historical image parts are sanitized to the IMAGE_PROCESSED sentinel, which the message-preparation filter wrongly treats as a valid image and forwards to the xAI vision API, producing the AI_APICallError. The goal is to ensure only genuine image data ever reaches the model while preserving conversational text history.

Task 1: Task 1.1: Stop treating `IMAGE_PROCESSED` as a valid image in message preparation

Correct the historical-messages filter so the sentinel placeholder is removed instead of retained.

• Update the message-mapping/filter logic in app/actions.tsx (lines ~394–434) so that an image part is considered valid only when it is a real data: URL; the IMAGE_PROCESSED sentinel should be filtered out of the content sent to the model.
• Ensure that stripping the sentinel does not leave malformed message objects — messages whose only content was the placeholder image should retain their remaining text parts, and empty content arrays should be handled gracefully.
• Keep the existing diagnostic logging (filteredImagesCount / retainedImagesCount) so the corrected behavior is observable.

Task 2: Task 1.2: Make the researcher's vision-model selection defensive

Guard against any future invalid image part causing a vision model to be selected with unusable content.

• Update the hasImage computation in lib/agents/researcher.tsx (lines ~108–133) so it only counts image parts that contain real image data (a data: URL or live image URL), not sentinel/placeholder strings.
• This ensures getModel(hasImage) is driven by genuinely usable imagery and prevents the trace log from reporting hasImage: true when no real image is present.

🤖 Prompt for AI agents

This phase repairs the resolution search image pipeline so that only genuine
image data reaches the xAI vision API — fixing the core bug where subsequent
searches fail after the `IMAGE_PROCESSED` sentinel is mistakenly forwarded as a
valid image.

**Task 1.1 — `app/actions.tsx` (lines ~394–434):**
- Locate the message-mapping/filter logic that prepares historical messages
before sending them to the model.
- Update the image-part validation so that a part is only retained if its
content is a real `data:` URL (e.g., starts with `data:`). The `IMAGE_PROCESSED`
sentinel string must be filtered out entirely.
- After filtering image parts from a message, ensure the remaining message
object is still well-formed:
- Messages whose only content was the sentinel image should still be included
but with only their text parts.
  - Guard against producing messages with empty content arrays.
- Retain the existing `filteredImagesCount` / `retainedImagesCount` diagnostic
logging, updating the logic so it accurately reflects the new filtering
behavior.

**Task 1.2 — `lib/agents/researcher.tsx` (lines ~108–133):**
- Locate the `hasImage` computation that drives `getModel(hasImage)`.
- Update it so that only image parts containing real image data (a `data:` URL
or a live image URL) are counted — sentinel/placeholder strings like
`IMAGE_PROCESSED` must not be counted.
- This prevents `hasImage` from being `true` when no usable image is actually
present, avoiding incorrect vision-model selection.

Phase 2: Fix Authentication and System-Prompt Handling

This phase eliminates the noisy auth errors and the database crash visible in the logs. An unauthenticated request resolves the user ID to the string "anonymous", which is then passed into a UUID-typed database query in getSystemPrompt, throwing an error (the searchParams cause in the trace). The drawing-context save and chat save also fail repeatedly for unauthenticated sessions. The goal is to make these paths short-circuit cleanly instead of erroring.

Task 1: Task 2.1: Short-circuit system-prompt lookup for non-authenticated users

Prevent getSystemPrompt from issuing a UUID query with the "anonymous" value.

• Update getSystemPrompt in lib/actions/chat.ts (lines ~274–290) to return null early when the user ID is missing or equals "anonymous" (mirroring the existing guards in getChat and updateDrawingContext), avoiding the failed DB query and the resulting error log.

Task 2: Task 2.2: Make drawing-context persistence fail quietly for unauthenticated sessions

Stop the repeated updateDrawingContext: Invalid or missing user ID error spam.

• Update updateDrawingContext in lib/actions/chat.ts (lines ~228–253) so that an unauthenticated user ID results in a quiet no-op/skip (returning a benign result) rather than an error-level log on every debounced drawing change.
• Optionally guard the client trigger in components/chat.tsx (lines ~104–114) so the debounced save is skipped when there is no authenticated session context, reducing redundant calls.

Task 3: Task 2.3: Align chat-save behavior with the authentication state

Ensure onSetAIState degrades gracefully when no session is present.

• Review onSetAIState in app/actions.tsx (lines ~732–794) so that the "not authenticated, chat not saved" path is treated as an expected, low-severity skip rather than an error, keeping behavior consistent with the other auth guards and avoiding misleading error logs.

🤖 Prompt for AI agents

This phase eliminates database crashes and auth error noise by ensuring all
unauthenticated code paths short-circuit cleanly rather than passing
`"anonymous"` into UUID-typed DB queries.

**Task 2.1 — `lib/actions/chat.ts` `getSystemPrompt` (lines ~274–290):**
- Add an early-return guard at the top of `getSystemPrompt` that returns `null`
when the user ID is falsy or equals the string `"anonymous"`.
- Mirror the same guard pattern already used in `getChat` and
`updateDrawingContext` in the same file for consistency.

**Task 2.2 — `lib/actions/chat.ts` `updateDrawingContext` (lines ~228–253):**
- Update the unauthenticated-user handling so that instead of logging at `error`
level, the function performs a quiet no-op and returns a benign result.
- Optionally, in `components/chat.tsx` (lines ~104–114), add a client-side guard
so the debounced `updateDrawingContext` call is skipped entirely when there is
no authenticated session context, reducing redundant network calls.

**Task 2.3 — `app/actions.tsx` `onSetAIState` (lines ~732–794):**
- Locate the branch that handles the case where a user is not authenticated and
the chat is not saved.
- Change the log level / handling of this branch from `error` to a low-severity
skip (e.g., `debug` or `info`), keeping it consistent with the other auth guards
and avoiding misleading error logs in production.

Phase 3: Harden Server-Side Streaming Against Failures

This phase addresses the "page refreshes" / 60-second Vercel Runtime Timeout symptom. Currently the AI_APICallError thrown inside researcher() propagates into the fire-and-forget processEvents() with no try/catch, leaving the uiStream unclosed so the client stalls and the function eventually times out. The goal is to ensure any agent failure finalizes the stream and surfaces a clean error.

Task 1: Task 3.1: Catch agent failures and finalize the stream

Ensure the researcher/resolution-search flow never leaves a dangling open stream.

• Wrap the streamText/agent invocation in lib/agents/researcher.tsx (and the equivalent call site in processEvents within app/actions.tsx) in error handling so that an AI_APICallError (or any agent error) is caught, the uiStream/summaryStream are properly completed (.done() / .error()), and an error indicator is written instead of leaving the stream open until timeout.
• Make sure the AI state is finalized appropriately on the error path so the next request starts from a clean history.

Task 2: Task 3.2: Provide consistent client-visible error feedback

Ensure failures present a clear message rather than a silent stall.

• Confirm/extend error handling at the client entry points — components/chat-panel.tsx handleSubmit (which currently has no try/catch) and the already-handled components/resolution-carousel.tsx handleQCXAnalysis — so a failed submit surfaces a toast/error state rather than an unhandled rejection, matching the existing toast pattern used in the carousel.

🤖 Prompt for AI agents

This phase prevents the 60-second Vercel timeout and page-refresh symptom by
ensuring agent failures always close the UI stream and surface a clean error to
the client.

**Task 3.1 — `lib/agents/researcher.tsx` and `app/actions.tsx`
`processEvents`:**
- Wrap the `streamText`/agent invocation in `lib/agents/researcher.tsx` with a
try/catch block.
- On catch: call `.done()` or `.error()` on the `uiStream`/`summaryStream` to
close them, write an error indicator to the stream instead of leaving it open,
and finalize AI state so the next request starts from a clean history.
- Apply the same try/catch pattern to the equivalent call site in
`processEvents` inside `app/actions.tsx` so that an `AI_APICallError` or any
other agent error is caught at that level as well.
- The key invariant: the stream must always be finalized (success or error) — it
must never be left open until the Vercel function times out.

**Task 3.2 — `components/chat-panel.tsx` `handleSubmit`:**
- Add a try/catch around the submit invocation in `handleSubmit` (currently has
no error handling).
- On catch, surface the error as a toast/error state, matching the existing
toast pattern already used in `components/resolution-carousel.tsx`
`handleQCXAnalysis`.
- Confirm that `components/resolution-carousel.tsx` `handleQCXAnalysis` already
handles this correctly; extend or align if needed.

Research

This is a Next.js application using the Vercel AI RSC (ai/rsc) pattern. The resolution-search feature lets users capture map imagery (Mapbox + Google Satellite) and run a vision-model analysis. The flow runs through the submit server action in app/actions.tsx, which prepares message history, calls AI agents (lib/agents/researcher.tsx, lib/agents/resolution-search.tsx), streams UI back, and persists state. Auth is cookie-based via Supabase SSR (lib/auth/get-current-user.ts), and chat/drawing persistence lives in lib/actions/chat.ts. After a resolution search, image parts in AI state are replaced with an IMAGE_PROCESSED sentinel to avoid storing large base64 blobs.

---

🚀 Next Steps

🤖 All AI agent prompts combined

Task: 1

This phase repairs the resolution search image pipeline so that only genuine
image data reaches the xAI vision API — fixing the core bug where subsequent
searches fail after the `IMAGE_PROCESSED` sentinel is mistakenly forwarded as a
valid image.

**Task 1.1 — `app/actions.tsx` (lines ~394–434):**
- Locate the message-mapping/filter logic that prepares historical messages
before sending them to the model.
- Update the image-part validation so that a part is only retained if its
content is a real `data:` URL (e.g., starts with `data:`). The `IMAGE_PROCESSED`
sentinel string must be filtered out entirely.
- After filtering image parts from a message, ensure the remaining message
object is still well-formed:
- Messages whose only content was the sentinel image should still be included
but with only their text parts.
  - Guard against producing messages with empty content arrays.
- Retain the existing `filteredImagesCount` / `retainedImagesCount` diagnostic
logging, updating the logic so it accurately reflects the new filtering
behavior.

**Task 1.2 — `lib/agents/researcher.tsx` (lines ~108–133):**
- Locate the `hasImage` computation that drives `getModel(hasImage)`.
- Update it so that only image parts containing real image data (a `data:` URL
or a live image URL) are counted — sentinel/placeholder strings like
`IMAGE_PROCESSED` must not be counted.
- This prevents `hasImage` from being `true` when no usable image is actually
present, avoiding incorrect vision-model selection.
===============================================================================

Task: 2

This phase eliminates database crashes and auth error noise by ensuring all
unauthenticated code paths short-circuit cleanly rather than passing
`"anonymous"` into UUID-typed DB queries.

**Task 2.1 — `lib/actions/chat.ts` `getSystemPrompt` (lines ~274–290):**
- Add an early-return guard at the top of `getSystemPrompt` that returns `null`
when the user ID is falsy or equals the string `"anonymous"`.
- Mirror the same guard pattern already used in `getChat` and
`updateDrawingContext` in the same file for consistency.

**Task 2.2 — `lib/actions/chat.ts` `updateDrawingContext` (lines ~228–253):**
- Update the unauthenticated-user handling so that instead of logging at `error`
level, the function performs a quiet no-op and returns a benign result.
- Optionally, in `components/chat.tsx` (lines ~104–114), add a client-side guard
so the debounced `updateDrawingContext` call is skipped entirely when there is
no authenticated session context, reducing redundant network calls.

**Task 2.3 — `app/actions.tsx` `onSetAIState` (lines ~732–794):**
- Locate the branch that handles the case where a user is not authenticated and
the chat is not saved.
- Change the log level / handling of this branch from `error` to a low-severity
skip (e.g., `debug` or `info`), keeping it consistent with the other auth guards
and avoiding misleading error logs in production.
===============================================================================

Task: 3

This phase prevents the 60-second Vercel timeout and page-refresh symptom by
ensuring agent failures always close the UI stream and surface a clean error to
the client.

**Task 3.1 — `lib/agents/researcher.tsx` and `app/actions.tsx`
`processEvents`:**
- Wrap the `streamText`/agent invocation in `lib/agents/researcher.tsx` with a
try/catch block.
- On catch: call `.done()` or `.error()` on the `uiStream`/`summaryStream` to
close them, write an error indicator to the stream instead of leaving it open,
and finalize AI state so the next request starts from a clean history.
- Apply the same try/catch pattern to the equivalent call site in
`processEvents` inside `app/actions.tsx` so that an `AI_APICallError` or any
other agent error is caught at that level as well.
- The key invariant: the stream must always be finalized (success or error) — it
must never be left open until the Vercel function times out.

**Task 3.2 — `components/chat-panel.tsx` `handleSubmit`:**
- Add a try/catch around the submit invocation in `handleSubmit` (currently has
no error handling).
- On catch, surface the error as a toast/error state, matching the existing
toast pattern already used in `components/resolution-carousel.tsx`
`handleQCXAnalysis`.
- Confirm that `components/resolution-carousel.tsx` `handleQCXAnalysis` already
handles this correctly; extend or align if needed.

💡 Iterate on the plan with: `@coderabbitai` <feedback>

Example Feedback
- `@coderabbitai` You can skip phase 3. Add a simple unit test case for phase 2.
- `@coderabbitai` For design choice 1 go ahead with option 3 and replan.

---

💬 Have feedback or questions? Drop into our discord!

[ngoiyaeric]

@coderabbitai did you take in this input @coderabbitai plan to resolve this Based on the error logs and codebase analysis, you're experiencing authentication and database query failures that are causing page refreshes and preventing subsequent actions from working.

Root Cause Analysis

The primary issue is that the application is using 'anonymous' as a hardcoded user ID in app/actions.tsx line 491, but database operations expect valid UUIDs. This causes cascading failures across multiple systems. 1

Specific Issues

1. System Prompt Query Failure
The getSystemPrompt function in lib/actions/chat.ts is being called with 'anonymous' as the userId, which causes a database query to fail because 'anonymous' is not a valid UUID in the users table. 2

2. Drawing Context Update Failure
The updateDrawingContext function requires a valid user ID from getCurrentUserIdOnServer(), but when authentication fails, it returns an error "Invalid or missing user ID". 3

3. Chat Save Failure
The onSetAIState function checks for user authentication and fails to save chats when the user is not authenticated, logging "User not authenticated. Chat not saved." 4

4. Image Processing Error
The AI API (api.x.ai) is rejecting image data with "Downloaded response does not contain a valid JPG, PNG, WebP, or ICO image." This suggests the image pipeline is sending invalid image data to the API. 5

Recommended Fixes

1. Fix Anonymous User Handling
Replace the hardcoded 'anonymous' user ID in app/actions.tsx with proper authentication handling. Either:

• Implement a guest user system with valid UUIDs
• Skip database operations for unauthenticated users
• Require authentication before allowing chat operations

2. Add Null Checks
Add proper null checks before calling getSystemPrompt and other database operations that require valid user IDs. 6

3. Fix Image Pipeline
Investigate the image processing pipeline to ensure valid image data is being sent to the AI API. The logs show the image pipeline trace indicates hasImage: true but the content structure shows hasImage: false, suggesting a mismatch in image handling. 7

Notes

The Vercel timeout error (60 seconds) is likely a symptom of these authentication failures causing the application to hang while waiting for database operations that ultimately fail. The authentication system needs to be reviewed to ensure consistent user ID handling across all server actions and API routes. 8

Wiki pages you might want to explore:

• Chat History and Message Storage (QueueLab/QCX)

Citations

File: app/actions.tsx (L446-462)

  const hasImage = messageParts.some(part => part.type === 'image')
  console.log('messageParts structure:', {
    parts: messageParts.map(p => ({
      type: p.type,
      length: p.type === 'text' ? p.text.length : undefined
    })),
    hasImage
  })
  const content: CoreMessage['content'] = hasImage
    ? messageParts
    : messageParts.map(part => (part.type === 'text' ? part.text : '')).join('\n')
  console.log('Final content structure:', {
    hasImage,
    contentType: typeof content,
    isArray: Array.isArray(content),
    partsCount: Array.isArray(content) ? content.length : 'N/A'
  })

File: app/actions.tsx (L491-493)

  const userId = 'anonymous'
  const currentSystemPrompt = (await getSystemPrompt(userId)) || ''
  const mapProvider = formData?.get('mapProvider') as 'mapbox' | 'google'

File: app/actions.tsx (L689-750)

  onSetAIState: async ({ state }) => {
    'use server'

    if (!state.messages.some(e => e.type === 'response')) {
      return
    }

    const { chatId, messages } = state
    const createdAt = new Date()
    const path = `/search/${chatId}`

    let title = 'Untitled Chat'
    if (messages.length > 0) {
      const firstMessageContent = messages[0].content
      if (typeof firstMessageContent === 'string') {
        try {
          const parsedContent = JSON.parse(firstMessageContent)
          title = parsedContent.input?.substring(0, 100) || 'Untitled Chat'
        } catch (e) {
          title = firstMessageContent.substring(0, 100)
        }
      } else if (Array.isArray(firstMessageContent)) {
        const textPart = (
          firstMessageContent as { type: string; text?: string }[]
        ).find(p => p.type === 'text')
        title =
          textPart && textPart.text
            ? textPart.text.substring(0, 100)
            : 'Image Message'
      }
    }

    const updatedMessages: AIMessage[] = [
      ...messages,
      {
        id: nanoid(),
        role: 'assistant',
        content: `end`,
        type: 'end'
      }
    ]

    const { getCurrentUserIdOnServer } = await import(
      '@/lib/auth/get-current-user'
    )
    const actualUserId = await getCurrentUserIdOnServer()

    if (!actualUserId) {
      console.error('onSetAIState: User not authenticated. Chat not saved.')
      return
    }

    const chat: Chat = {
      id: chatId,
      createdAt,
      userId: actualUserId,
      path,
      title,
      messages: updatedMessages
    }
    await saveChat(chat, actualUserId)
  }

File: lib/actions/chat.ts (L186-211)

export async function updateDrawingContext(chatId: string, contextData: { drawnFeatures: any[], cameraState: any }) {
  const userId = await getCurrentUserIdOnServer();
  if (!userId) {
    console.error('updateDrawingContext: Could not get current user ID.');
    return { error: 'User not authenticated' };
  }

  const newDrawingMessage: DbNewMessage = {
    userId: userId,
    chatId: chatId,
    role: 'data',
    content: JSON.stringify(contextData),
    createdAt: new Date(),
  };

  try {
    const savedMessage = await dbCreateMessage(newDrawingMessage);
    if (!savedMessage) {
      throw new Error('Failed to save drawing context message.');
    }
    return { success: true, messageId: savedMessage.id };
  } catch (error) {
    console.error('updateDrawingContext: Error saving drawing context message:', error);
    return { error: 'Failed to save drawing context message' };
  }
}

File: lib/actions/chat.ts (L232-248)

export async function getSystemPrompt(
  userId: string
): Promise<string | null> {
  if (!userId) return null

  try {
    const result = await db.select({ systemPrompt: users.systemPrompt })
      .from(users)
      .where(eq(users.id, userId))
      .limit(1);

    return result[0]?.systemPrompt || null;
  } catch (error) {
    console.error('getSystemPrompt: Error:', error)
    return null
  }
}

File: lib/agents/researcher.tsx (L107-133)

  // Check if any message contains an image
  const hasImage = messages.some(message =>
    Array.isArray(message.content) &&
    message.content.some(part => part.type === 'image')
  )

  const lastUserMessage = [...messages].reverse().find(m => m.role === 'user')
  console.log('Researcher - Image pipeline trace:', {
    hasImage,
    totalMessages: messages.length,
    messagesWithImages: messages.filter(
      m =>
        Array.isArray(m.content) && m.content.some(p => p.type === 'image')
    ).length,
    lastUserMessageContentStructure: lastUserMessage
      ? {
          type: typeof lastUserMessage.content,
          isArray: Array.isArray(lastUserMessage.content),
          parts: Array.isArray(lastUserMessage.content)
            ? lastUserMessage.content.map(p => ({
                type: p.type,
                hasImage: p.type === 'image'
              }))
            : 'string'
        }
      : 'none'
  })

File: app/search/[id]/page.tsx (L29-35)

  const userId = await getCurrentUserIdOnServer();

  if (!userId) {
    // If no user, redirect to login or show appropriate page
    // For now, redirecting to home, but a login page would be better.
    redirect('/');
  }

[coderabbitai]

Coding Plan

Summary

• Fix the auth root cause by resolving the user/session once inside the request scope and threading it through to system-prompt lookup, persistence, and lifecycle callbacks — eliminating the "anonymous" degradation, the getSystemPrompt searchParams crash, and the onSetAIState/updateDrawingContext errors.
• Repair the image pipeline by stripping the IMAGE_PROCESSED sentinel, validating real image content, and normalizing image-bearing messages into proper part arrays so only genuine imagery reaches the xAI vision API.
• Harden server-side streaming and AI-state finalization so agent errors close the stream, surface a clean client error, and leave a recoverable state — preventing the 60s timeout and the "subsequent searches fail" pattern.
• Reproduce the sequence-dependent failure and verify session persistence and clean logs across repeated actions to confirm the root causes are resolved.

Design Choices

Design Choice 1: How should the `IMAGE_PROCESSED` sentinel and other non-image content be handled when preparing message history for the model?

Options Considered:

1. Strip IMAGE_PROCESSED image parts entirely from the messages sent to the model, while keeping the rest of the message content (text) intact, and validate that every remaining image part is genuine image data.
2. Keep retaining the sentinel in the filter but recompute hasImage in the researcher so a vision model isn't selected, hoping the API ignores it.

Chosen Option: 1

Rationale: Option 1 — Stripping the sentinel and validating remaining image content is the only reliable fix, since any image part sent to xAI must be a real data URL; recomputing hasImage alone still forwards the invalid part.

Design Choice 2: Why does the user ID become `"anonymous"` between requests, and where should it be resolved?

Options Considered:

1. Resolve the user/session once at the top of the request (inside submit, within a valid request scope) and thread the resolved userId through to all downstream calls (system prompt, persistence, lifecycle callbacks) instead of re-resolving in detached/fire-and-forget contexts.
2. Re-call getCurrentUserIdOnServer() independently in each helper and lifecycle callback (current behavior).

Chosen Option: 1

Rationale: Option 1 — cookies() only works inside an active request boundary; the AI RSC lifecycle callbacks (onSetAIState) and fire-and-forget processEvents() run after/outside that boundary, so capturing the user ID early and passing it down is the root-cause fix for the "anonymous" degradation and the searchParams crash.

💡 User Tips

Regenerate the plan with different choices with @coderabbitai <feedback>.

Implementation Steps

Phase 1: Diagnose and Fix Auth/Session Context Loss

This phase targets the root cause behind three of the logged errors — updateDrawingContext: Invalid or missing user ID, getSystemPrompt ... params: anonymous, and onSetAIState: User not authenticated. All three stem from getCurrentUserIdOnServer() returning null (coerced to "anonymous") because cookies() cannot read the session in the execution context. The goal is to first confirm exactly where and why the session is lost, then ensure the user ID is resolved once inside a valid request scope and reused everywhere downstream.

Task 1: Task 1.1: Investigate where and why the session degrades to "anonymous"

Establish the precise execution contexts in which getCurrentUserIdOnServer() returns null.

• Trace every call to getCurrentUserIdOnServer() in the resolution-search/submit path: submit (app/actions.tsx line ~93), onSetAIState (lines ~732–794), and updateDrawingContext (lib/actions/chat.ts lines ~228–253).
• Confirm whether each call runs inside an active Next.js request boundary; specifically verify that onSetAIState and the fire-and-forget processEvents() execute after the response is sent, where cookies() from next/headers no longer has access to the request — explaining why the first call (in-request) succeeds but later/derived calls report "anonymous".
• Document the finding (in code comments / PR description) connecting it to the "first works, subsequent fail" pattern and the repeated Invalid or missing user ID log entries.

Task 2: Task 1.2: Resolve the user ID once and thread it through the request

Eliminate re-resolution of auth in detached contexts.

• In app/actions.tsx, resolve userId/session a single time at the start of submit (within request scope) and pass it explicitly into all downstream consumers — getSystemPrompt, onSetAIState's save path, and any persistence triggered from processEvents() — instead of relying on those callbacks to re-call getCurrentUserIdOnServer().
• Ensure the captured userId is closed over by the lifecycle/fire-and-forget callbacks so they no longer depend on cookies() being available when they run.

Task 3: Task 1.3: Harden the server context to prevent the `searchParams` crash

Directly address the TypeError: Cannot read properties of undefined (reading 'searchParams') originating inside Next.js's queryWithCache/startActiveSpan wrapper.

• Recognize that queryWithCache/startActiveSpan are Next.js internal instrumentation frames; the searchParams undefined error occurs because the Drizzle query in getSystemPrompt runs through Next.js's cache/tracing layer outside a valid request context (the same detached context identified in Task 1.1).
• Prevent the DB query from ever executing in that broken context by short-circuiting getSystemPrompt for non-authenticated users (see Task 1.4) and by ensuring system-prompt resolution happens within the request scope (Task 1.2), so no db.select() is triggered from a detached/cache-wrapped path with "anonymous".
• Verify no DB-touching action in the resolution-search path is invoked from a context lacking request cookies; where unavoidable, pass pre-resolved values rather than triggering a context-dependent query.

Task 4: Task 1.4: Short-circuit system-prompt lookup for non-authenticated users

Prevent getSystemPrompt from issuing a UUID query with the "anonymous" value (resolves the getSystemPrompt: Failed query ... params: anonymous log).

• Update getSystemPrompt in lib/actions/chat.ts (lines ~274–290) to return null early when the user ID is missing or equals "anonymous" (mirroring the existing guards in getChat and updateDrawingContext), avoiding the failed DB query, the Next.js cache-wrapper crash, and the resulting error log.

Task 5: Task 1.5: Make drawing-context and chat persistence fail quietly when unauthenticated

Stop the repeated updateDrawingContext: Invalid or missing user ID and onSetAIState: User not authenticated error spam.

• Update updateDrawingContext in lib/actions/chat.ts (lines ~228–253) so an unauthenticated user ID results in a quiet no-op/skip (returning a benign result) rather than an error-level log on every debounced drawing change.
• Optionally guard the client trigger in components/chat.tsx (lines ~104–114) so the debounced save is skipped when there is no authenticated session context.
• Review onSetAIState in app/actions.tsx (lines ~732–794) so the "not authenticated, chat not saved" path uses the threaded userId from Task 1.2 and is treated as an expected, low-severity skip rather than an error.

🤖 Prompt for AI agents

This phase resolves the auth/session context loss that causes the user ID to
degrade to `"anonymous"` in detached execution contexts, which in turn crashes
`getSystemPrompt` via Next.js's internal `queryWithCache`/`startActiveSpan`
wrapper and spams error logs in `updateDrawingContext` and `onSetAIState`.

**Task 1.1 — Trace `getCurrentUserIdOnServer()` call sites:**
- Review every call to `getCurrentUserIdOnServer()` in the
resolution-search/submit path: `submit` (`app/actions.tsx` line ~93),
`onSetAIState` (lines ~732–794), and `updateDrawingContext`
(`lib/actions/chat.ts` lines ~228–253).
- Confirm which calls run inside an active Next.js request boundary vs. in
detached/fire-and-forget contexts (e.g., `onSetAIState`, `processEvents()`)
where `cookies()` from `next/headers` is unavailable.
- Add code comments or a PR description note documenting the finding and linking
it to the "first works, subsequent fail" pattern.

**Task 1.2 — `app/actions.tsx` `submit`:**
- Resolve `userId`/session a single time at the very start of `submit` (within
request scope).
- Pass the resolved `userId` explicitly into all downstream consumers:
`getSystemPrompt`, `onSetAIState`'s save path, and any persistence called from
`processEvents()`.
- Ensure the captured `userId` is closed over by lifecycle/fire-and-forget
callbacks so they never re-call `getCurrentUserIdOnServer()` from a detached
context.

**Task 1.3 — Prevent DB queries in broken contexts:**
- Ensure `getSystemPrompt` is called within request scope using the pre-resolved
`userId` from Task 1.2, so no Drizzle query is triggered through Next.js's
`queryWithCache`/`startActiveSpan` wrapper from a detached context.
- Audit other DB-touching actions in the resolution-search path for the same
pattern; pass pre-resolved values rather than triggering context-dependent
queries.

**Task 1.4 — `lib/actions/chat.ts` `getSystemPrompt` (lines ~274–290):**
- Add an early-return guard that returns `null` when the user ID is falsy or
equals `"anonymous"`.
- Mirror the guard pattern already used in `getChat` and `updateDrawingContext`
for consistency.

**Task 1.5 — `lib/actions/chat.ts` `updateDrawingContext` (lines ~228–253) and
`app/actions.tsx` `onSetAIState` (lines ~732–794):**
- In `updateDrawingContext`: change the unauthenticated-user handling from an
`error`-level log to a quiet no-op returning a benign result.
- Optionally, in `components/chat.tsx` (lines ~104–114): add a client-side guard
to skip the debounced `updateDrawingContext` call when there is no authenticated
session context.
- In `onSetAIState`: use the threaded `userId` from Task 1.2; change the "not
authenticated, chat not saved" branch from an `error`-level log to a
low-severity skip (e.g., `debug` or `info`).

Phase 2: Repair the Resolution Search Image Pipeline

This phase fixes the AI_APICallError: Downloaded response does not contain a valid JPG, PNG, WebP, or ICO image and the misleading Researcher - Image pipeline trace: hasImage: true log. After a resolution search, historical image parts are sanitized to the IMAGE_PROCESSED sentinel, which the message-preparation filter wrongly treats as a valid image and forwards to the xAI vision API. The goal is to ensure only genuine, well-formed image data ever reaches the model.

Task 1: Task 2.1: Strip the sentinel and validate real image content before the model call

Correct the historical-messages filter so only genuine image data survives, and add explicit validation of image URLs/content.

• Update the message-mapping/filter logic in app/actions.tsx (lines ~394–434) so an image part is considered valid only when it is a real data: URL (or a genuine live image URL); the IMAGE_PROCESSED sentinel must be filtered out of the content sent to the model.
• Add an explicit image-content validation step immediately before the agent/model call: assert each remaining { type: 'image' } part contains a non-empty, correctly-formatted image value; drop or reject anything that is not, so no invalid value can reach the xAI API (directly preventing the AI_APICallError).
• Keep the existing diagnostic logging (filteredImagesCount / retainedImagesCount) so the corrected behavior is observable, and log when validation drops a part.

Task 2: Task 2.2: Normalize image-containing messages into proper part arrays

Ensure messages carrying images are always structured as content-part arrays, never plain strings (addresses the lastUserMessageContentStructure: { type: 'string', isArray: false } anomaly seen alongside hasImage: true).

• In app/actions.tsx, add a normalization step in message preparation so any message intended to contain an image is represented as a structured content: [...] array of parts rather than a plain string, keeping text and image parts consistent.
• Ensure that after filtering/validation, messages whose only content was a stripped placeholder retain their remaining text parts and never collapse into a malformed shape; handle empty content arrays gracefully.

Task 3: Task 2.3: Make the researcher's vision-model selection defensive

Guard against any future invalid image part causing a vision model to be selected with unusable content.

• Update the hasImage computation in lib/agents/researcher.tsx (lines ~108–133) so it only counts image parts that contain real image data (a data: URL or live image URL), not sentinel/placeholder strings.
• This ensures getModel(hasImage) is driven by genuinely usable imagery and prevents the trace log from reporting hasImage: true when no real image is present.

🤖 Prompt for AI agents

This phase repairs the resolution search image pipeline so that only genuine
image data reaches the xAI vision API — fixing the `AI_APICallError` that occurs
when the `IMAGE_PROCESSED` sentinel is mistakenly forwarded as a valid image on
subsequent searches.

**Task 2.1 — `app/actions.tsx` (lines ~394–434):**
- Update the message-mapping/filter logic so an image part is only retained if
it contains a real `data:` URL or a genuine live image URL. The
`IMAGE_PROCESSED` sentinel must be filtered out entirely.
- Immediately before the agent/model call, add an explicit validation step that
asserts every remaining `{ type: 'image' }` part has a non-empty,
correctly-formatted image value; drop any part that does not pass.
- Retain and update the existing `filteredImagesCount` / `retainedImagesCount`
diagnostic logging to reflect the new behavior; add a log entry when the
validation step drops a part.

**Task 2.2 — `app/actions.tsx` message normalization:**
- Add a normalization step in message preparation so any message carrying an
image is represented as a structured `content: [...]` array of parts (not a
plain string).
- After filtering/validation, ensure messages whose only content was a stripped
placeholder retain their remaining text parts and are never left with an empty
content array; handle this edge case gracefully.

**Task 2.3 — `lib/agents/researcher.tsx` (lines ~108–133):**
- Update the `hasImage` computation so only image parts containing real image
data (a `data:` URL or a live image URL) are counted — sentinel/placeholder
strings like `IMAGE_PROCESSED` must not be counted.
- This prevents `hasImage` from being `true` when no usable image is present,
avoiding incorrect vision-model selection via `getModel(hasImage)`.

Phase 3: Harden Server-Side Streaming, Timeouts, and Resilience

This phase addresses the "page refreshes" / Vercel Runtime Timeout Error: Task timed out after 60 seconds symptom and ensures subsequent requests recover cleanly. Currently the AI_APICallError thrown inside researcher() propagates into the fire-and-forget processEvents() with no try/catch, leaving the uiStream unclosed so the client stalls until timeout, and leaving AI state in a state that breaks the next request.

Task 1: Task 3.1: Catch agent failures and finalize the stream

Ensure the researcher/resolution-search flow never leaves a dangling open stream (resolves the 60-second timeout).

• Wrap the streamText/agent invocation in lib/agents/researcher.tsx (and the equivalent call site in processEvents within app/actions.tsx) in error handling so that an AI_APICallError (or any agent error) is caught, the uiStream/summaryStream are properly completed (.done() / .error()), and an error indicator is written instead of leaving the stream open until timeout.
• Make sure the AI state is finalized appropriately on the error path so the next request starts from a clean history.

Task 2: Task 3.2: Ensure subsequent requests recover after a failure

Address the "subsequent ones don't work" pattern at the state level, not just the stream level.

• After any error in processEvents()/agent flow, ensure AI state is left without lingering invalid image parts or partial messages that would re-trigger the same AI_APICallError on the next attempt (coordinating with Phase 2's sentinel stripping).
• Verify that a failed resolution search does not block or corrupt a follow-up search — the isAnalyzing reset in resolution-carousel.tsx plus clean AI-state finalization should allow immediate retry.
• Consider explicitly bounding long-running agent work so it fails fast with a surfaced error rather than silently approaching the Vercel 60s limit.

Task 3: Task 3.3: Provide consistent client-visible error feedback

Ensure failures present a clear message rather than a silent stall or implicit refresh.

• Confirm/extend error handling at the client entry points — components/chat-panel.tsx handleSubmit (which currently has no try/catch) and the already-handled components/resolution-carousel.tsx handleQCXAnalysis — so a failed submit surfaces a toast/error state rather than an unhandled rejection, matching the existing toast pattern used in the carousel.

🤖 Prompt for AI agents

This phase prevents the 60-second Vercel timeout and page-refresh symptom by
ensuring agent failures always close the UI stream, surface a clean error to the
client, and leave AI state in a recoverable shape for subsequent requests.

**Task 3.1 — `lib/agents/researcher.tsx` and `app/actions.tsx`
`processEvents`:**
- Wrap the `streamText`/agent invocation in `lib/agents/researcher.tsx` with a
try/catch block.
- On catch: call `.done()` or `.error()` on the `uiStream`/`summaryStream` to
close them, write an error indicator to the stream, and finalize AI state so the
next request starts from a clean history.
- Apply the same try/catch pattern to the equivalent call site in
`processEvents` inside `app/actions.tsx`.
- Key invariant: the stream must always be finalized (success or error) — it
must never be left open until the Vercel function times out.

**Task 3.2 — `app/actions.tsx` `processEvents` and
`components/resolution-carousel.tsx`:**
- After any error in the agent/`processEvents()` flow, ensure AI state is
finalized without lingering invalid image parts or partial messages that would
re-trigger the same `AI_APICallError` on the next attempt.
- Verify `isAnalyzing` is reset in `resolution-carousel.tsx` on the error path
so immediate retry is possible.
- Consider adding an explicit timeout bound on long-running agent work so it
fails fast with a surfaced error rather than silently approaching the Vercel 60s
limit.

**Task 3.3 — `components/chat-panel.tsx` `handleSubmit`:**
- Add a try/catch around the submit invocation in `handleSubmit` (currently has
no error handling).
- On catch, surface the error as a toast/error state matching the existing toast
pattern in `components/resolution-carousel.tsx` `handleQCXAnalysis`.
- Confirm that `components/resolution-carousel.tsx` `handleQCXAnalysis` already
handles this correctly; extend or align if needed.

Phase 4: Reproduce and Verify the "First Works, Subsequent Fail" Fix

This phase confirms the root causes are actually resolved across repeated actions, since the defining symptom is intermittent and sequence-dependent.

Task 1: Task 4.1: Reproduce the failure sequence before and after the fix

Create a deterministic repro for the regression.

• Reproduce the original sequence: run one successful resolution search, then run a second/third — confirming the pre-fix behavior produces the AI_APICallError, the getSystemPrompt ... params: anonymous crash, and the 60s timeout on the later attempts.
• After applying Phases 1–3, repeat the same sequence and confirm subsequent searches succeed, no IMAGE_PROCESSED value reaches the API, and no timeout occurs.

Task 2: Task 4.2: Verify session persistence and clean logs across repeated actions

Confirm the auth root cause is fixed, not just masked.

• Verify that across repeated resolution searches and drawing-context saves the resolved userId remains stable (no degradation to "anonymous"), and that getSystemPrompt, updateDrawingContext, and onSetAIState no longer emit error-level logs for authenticated sessions.
• Verify the unauthenticated path now short-circuits cleanly (benign skips, no DB crash) and that the Researcher - Image pipeline trace reports hasImage correctly relative to actual image content.

🤖 Prompt for AI agents

This phase is a verification/QA phase to confirm all root causes are resolved
across repeated actions. No new code is written; the goal is to exercise the
fixed flows and validate behavior.

**Task 4.1 — Reproduce the failure sequence:**
- Run the original failure sequence manually (or via test): one successful
resolution search, then a second/third attempt.
- Before the fix: confirm the `AI_APICallError`, `getSystemPrompt ... params:
anonymous` crash, and 60s timeout are reproduced on subsequent attempts.
- After applying Phases 1–3: repeat the sequence and confirm subsequent searches
succeed, no `IMAGE_PROCESSED` value reaches the API, and no timeout occurs.

**Task 4.2 — Verify session and log cleanliness:**
- Across repeated resolution searches and drawing-context saves, confirm the
resolved `userId` remains stable and never degrades to `"anonymous"`.
- Confirm `getSystemPrompt`, `updateDrawingContext`, and `onSetAIState` no
longer emit error-level logs for authenticated sessions.
- Confirm the unauthenticated path short-circuits cleanly with benign skips and
no DB crash.
- Confirm the `Researcher - Image pipeline trace` reports `hasImage` correctly
relative to actual image content present in the request.

Research

This is a Next.js 15 application using the Vercel AI RSC (ai/rsc) pattern. The resolution-search feature lets users capture map imagery (Mapbox + Google Satellite) and run a vision-model analysis. The flow runs through the submit server action in app/actions.tsx, which resolves the user via cookie-based Supabase SSR auth (lib/auth/get-current-user.ts), prepares message history, calls AI agents (lib/agents/researcher.tsx, lib/agents/resolution-search.tsx), streams UI back, and persists state. DB access is a plain Drizzle + pg pool (lib/db/index.ts) with no project-level caching; the queryWithCache/startActiveSpan frames in the logs are Next.js's own internal instrumentation wrapping the query. After a resolution search, image parts in AI state are replaced with an IMAGE_PROCESSED sentinel to avoid storing large base64 blobs.

---

🚀 Next Steps

🤖 All AI agent prompts combined

Task: 1

This phase resolves the auth/session context loss that causes the user ID to
degrade to `"anonymous"` in detached execution contexts, which in turn crashes
`getSystemPrompt` via Next.js's internal `queryWithCache`/`startActiveSpan`
wrapper and spams error logs in `updateDrawingContext` and `onSetAIState`.

**Task 1.1 — Trace `getCurrentUserIdOnServer()` call sites:**
- Review every call to `getCurrentUserIdOnServer()` in the
resolution-search/submit path: `submit` (`app/actions.tsx` line ~93),
`onSetAIState` (lines ~732–794), and `updateDrawingContext`
(`lib/actions/chat.ts` lines ~228–253).
- Confirm which calls run inside an active Next.js request boundary vs. in
detached/fire-and-forget contexts (e.g., `onSetAIState`, `processEvents()`)
where `cookies()` from `next/headers` is unavailable.
- Add code comments or a PR description note documenting the finding and linking
it to the "first works, subsequent fail" pattern.

**Task 1.2 — `app/actions.tsx` `submit`:**
- Resolve `userId`/session a single time at the very start of `submit` (within
request scope).
- Pass the resolved `userId` explicitly into all downstream consumers:
`getSystemPrompt`, `onSetAIState`'s save path, and any persistence called from
`processEvents()`.
- Ensure the captured `userId` is closed over by lifecycle/fire-and-forget
callbacks so they never re-call `getCurrentUserIdOnServer()` from a detached
context.

**Task 1.3 — Prevent DB queries in broken contexts:**
- Ensure `getSystemPrompt` is called within request scope using the pre-resolved
`userId` from Task 1.2, so no Drizzle query is triggered through Next.js's
`queryWithCache`/`startActiveSpan` wrapper from a detached context.
- Audit other DB-touching actions in the resolution-search path for the same
pattern; pass pre-resolved values rather than triggering context-dependent
queries.

**Task 1.4 — `lib/actions/chat.ts` `getSystemPrompt` (lines ~274–290):**
- Add an early-return guard that returns `null` when the user ID is falsy or
equals `"anonymous"`.
- Mirror the guard pattern already used in `getChat` and `updateDrawingContext`
for consistency.

**Task 1.5 — `lib/actions/chat.ts` `updateDrawingContext` (lines ~228–253) and
`app/actions.tsx` `onSetAIState` (lines ~732–794):**
- In `updateDrawingContext`: change the unauthenticated-user handling from an
`error`-level log to a quiet no-op returning a benign result.
- Optionally, in `components/chat.tsx` (lines ~104–114): add a client-side guard
to skip the debounced `updateDrawingContext` call when there is no authenticated
session context.
- In `onSetAIState`: use the threaded `userId` from Task 1.2; change the "not
authenticated, chat not saved" branch from an `error`-level log to a
low-severity skip (e.g., `debug` or `info`).
===============================================================================

Task: 2

This phase repairs the resolution search image pipeline so that only genuine
image data reaches the xAI vision API — fixing the `AI_APICallError` that occurs
when the `IMAGE_PROCESSED` sentinel is mistakenly forwarded as a valid image on
subsequent searches.

**Task 2.1 — `app/actions.tsx` (lines ~394–434):**
- Update the message-mapping/filter logic so an image part is only retained if
it contains a real `data:` URL or a genuine live image URL. The
`IMAGE_PROCESSED` sentinel must be filtered out entirely.
- Immediately before the agent/model call, add an explicit validation step that
asserts every remaining `{ type: 'image' }` part has a non-empty,
correctly-formatted image value; drop any part that does not pass.
- Retain and update the existing `filteredImagesCount` / `retainedImagesCount`
diagnostic logging to reflect the new behavior; add a log entry when the
validation step drops a part.

**Task 2.2 — `app/actions.tsx` message normalization:**
- Add a normalization step in message preparation so any message carrying an
image is represented as a structured `content: [...]` array of parts (not a
plain string).
- After filtering/validation, ensure messages whose only content was a stripped
placeholder retain their remaining text parts and are never left with an empty
content array; handle this edge case gracefully.

**Task 2.3 — `lib/agents/researcher.tsx` (lines ~108–133):**
- Update the `hasImage` computation so only image parts containing real image
data (a `data:` URL or a live image URL) are counted — sentinel/placeholder
strings like `IMAGE_PROCESSED` must not be counted.
- This prevents `hasImage` from being `true` when no usable image is present,
avoiding incorrect vision-model selection via `getModel(hasImage)`.
===============================================================================

Task: 3

This phase prevents the 60-second Vercel timeout and page-refresh symptom by
ensuring agent failures always close the UI stream, surface a clean error to the
client, and leave AI state in a recoverable shape for subsequent requests.

**Task 3.1 — `lib/agents/researcher.tsx` and `app/actions.tsx`
`processEvents`:**
- Wrap the `streamText`/agent invocation in `lib/agents/researcher.tsx` with a
try/catch block.
- On catch: call `.done()` or `.error()` on the `uiStream`/`summaryStream` to
close them, write an error indicator to the stream, and finalize AI state so the
next request starts from a clean history.
- Apply the same try/catch pattern to the equivalent call site in
`processEvents` inside `app/actions.tsx`.
- Key invariant: the stream must always be finalized (success or error) — it
must never be left open until the Vercel function times out.

**Task 3.2 — `app/actions.tsx` `processEvents` and
`components/resolution-carousel.tsx`:**
- After any error in the agent/`processEvents()` flow, ensure AI state is
finalized without lingering invalid image parts or partial messages that would
re-trigger the same `AI_APICallError` on the next attempt.
- Verify `isAnalyzing` is reset in `resolution-carousel.tsx` on the error path
so immediate retry is possible.
- Consider adding an explicit timeout bound on long-running agent work so it
fails fast with a surfaced error rather than silently approaching the Vercel 60s
limit.

**Task 3.3 — `components/chat-panel.tsx` `handleSubmit`:**
- Add a try/catch around the submit invocation in `handleSubmit` (currently has
no error handling).
- On catch, surface the error as a toast/error state matching the existing toast
pattern in `components/resolution-carousel.tsx` `handleQCXAnalysis`.
- Confirm that `components/resolution-carousel.tsx` `handleQCXAnalysis` already
handles this correctly; extend or align if needed.
===============================================================================

Task: 4

This phase is a verification/QA phase to confirm all root causes are resolved
across repeated actions. No new code is written; the goal is to exercise the
fixed flows and validate behavior.

**Task 4.1 — Reproduce the failure sequence:**
- Run the original failure sequence manually (or via test): one successful
resolution search, then a second/third attempt.
- Before the fix: confirm the `AI_APICallError`, `getSystemPrompt ... params:
anonymous` crash, and 60s timeout are reproduced on subsequent attempts.
- After applying Phases 1–3: repeat the sequence and confirm subsequent searches
succeed, no `IMAGE_PROCESSED` value reaches the API, and no timeout occurs.

**Task 4.2 — Verify session and log cleanliness:**
- Across repeated resolution searches and drawing-context saves, confirm the
resolved `userId` remains stable and never degrades to `"anonymous"`.
- Confirm `getSystemPrompt`, `updateDrawingContext`, and `onSetAIState` no
longer emit error-level logs for authenticated sessions.
- Confirm the unauthenticated path short-circuits cleanly with benign skips and
no DB crash.
- Confirm the `Researcher - Image pipeline trace` reports `hasImage` correctly
relative to actual image content present in the request.

💡 Iterate on the plan with: `@coderabbitai` <feedback>

Example Feedback
- `@coderabbitai` You can skip phase 3. Add a simple unit test case for phase 2.
- `@coderabbitai` For design choice 1 go ahead with option 3 and replan.

---

💬 Have feedback or questions? Drop into our discord!

[coderabbitai]

Coding Plan

Summary

• Treat the issue as one cross-cutting reliability problem with three interacting failure chains (auth → DB crash, image pipeline → API error, missing error handling → timeout) that compound to produce the "first works, subsequent fail" pattern, so all phases are necessary together.
• Fix the auth root cause by adopting a single unauthenticated-user policy (skip DB-dependent features), resolving the user/session once inside the request scope and threading it downstream, removing the hardcoded "anonymous" fallback, and applying a unified pre-DB guard pattern.
• Repair the image pipeline by stripping the IMAGE_PROCESSED sentinel, validating real image content, and normalizing image-bearing messages into proper part arrays so only genuine imagery reaches the xAI vision API.
• Harden server-side streaming and AI-state finalization so agent errors close the stream, surface a clean client error, and leave a recoverable state — then reproduce and verify across repeated actions.

Design Choices

Design Choice 1: How should the `IMAGE_PROCESSED` sentinel and other non-image content be handled when preparing message history for the model?

Options Considered:

1. Strip IMAGE_PROCESSED image parts entirely from the messages sent to the model, while keeping the rest of the message content (text) intact, and validate that every remaining image part is genuine image data.
2. Keep retaining the sentinel in the filter but recompute hasImage in the researcher so a vision model isn't selected, hoping the API ignores it.

Chosen Option: 1

Rationale: Option 1 — Stripping the sentinel and validating remaining image content is the only reliable fix, since any image part sent to xAI must be a real data URL; recomputing hasImage alone still forwards the invalid part.

Design Choice 2: Why does the user ID become `"anonymous"` between requests, and where should it be resolved?

Options Considered:

1. Resolve the user/session once at the top of the request (inside submit, within a valid request scope) and thread the resolved userId through to all downstream calls (system prompt, persistence, lifecycle callbacks) instead of re-resolving in detached/fire-and-forget contexts.
2. Re-call getCurrentUserIdOnServer() independently in each helper and lifecycle callback (current behavior).

Chosen Option: 1

Rationale: Option 1 — cookies() only works inside an active request boundary; the AI RSC lifecycle callbacks (onSetAIState) and fire-and-forget processEvents() run after/outside that boundary, so capturing the user ID early and passing it down is the root-cause fix for the "anonymous" degradation and the searchParams crash.

Design Choice 3: What is the policy for unauthenticated (or session-lost) users in DB-dependent parts of the resolution-search flow?

Options Considered:

1. Assign a stable guest UUID — replace "anonymous" with a valid placeholder UUID so DB queries don't type-crash; requires deciding how/whether guest data is persisted.
2. Skip DB-dependent features for unauthenticated users — keep resolution search working in-memory/stream-only, but cleanly no-op all persistence (system prompt lookup, drawing-context save, chat save) when there is no valid user.
3. Require login — block the resolution-search/submit flow entirely until the user is authenticated.

Chosen Option: 2

Rationale: Option 2 — Skipping DB-dependent features is the least disruptive, preserves the working in-request experience, matches the existing guard pattern already present in getChat/updateDrawingContext, and avoids introducing guest-data persistence semantics or a hard login gate. The remaining root cause (session loss for authenticated users) is fixed by Assumption 2's threading, so this policy only governs genuinely unauthenticated requests.

💡 User Tips

Regenerate the plan with different choices with @coderabbitai <feedback>.

Implementation Steps

Phase 1: Diagnose and Fix Auth/Session Context Loss

This phase targets the auth → DB crash failure chain behind three of the logged errors — updateDrawingContext: Invalid or missing user ID, getSystemPrompt ... params: anonymous, and onSetAIState: User not authenticated. All three stem from getCurrentUserIdOnServer() returning null (coerced to the hardcoded "anonymous" string) because cookies() cannot read the session in the execution context. The goal is to first confirm exactly where and why the session is lost, then ensure the user ID is resolved once inside a valid request scope and reused everywhere downstream, remove the unsafe "anonymous" fallback, and apply a consistent pre-DB guard policy (per Assumption 3).

Task 1: Task 1.1: Investigate where and why the session degrades to "anonymous"

Establish the precise execution contexts in which getCurrentUserIdOnServer() returns null.

• Trace every call to getCurrentUserIdOnServer() in the resolution-search/submit path: submit (app/actions.tsx line ~93), onSetAIState (lines ~732–794), and updateDrawingContext (lib/actions/chat.ts lines ~228–253).
• Confirm whether each call runs inside an active Next.js request boundary; specifically verify that onSetAIState and the fire-and-forget processEvents() execute after the response is sent, where cookies() from next/headers no longer has access to the request — explaining why the first call (in-request) succeeds but later/derived calls report "anonymous".
• Document the finding (in code comments / PR description) connecting it to the "first works, subsequent fail" pattern and the repeated Invalid or missing user ID log entries.

Task 2: Task 1.2: Resolve the user ID once and thread it through the request

Eliminate re-resolution of auth in detached contexts.

• In app/actions.tsx, resolve userId/session a single time at the start of submit (within request scope) and pass it explicitly into all downstream consumers — getSystemPrompt, onSetAIState's save path, and any persistence triggered from processEvents() — instead of relying on those callbacks to re-call getCurrentUserIdOnServer().
• Ensure the captured userId is closed over by the lifecycle/fire-and-forget callbacks so they no longer depend on cookies() being available when they run.

Task 3: Task 1.3: Remove the hardcoded "anonymous" fallback string

Eliminate the unsafe sentinel value that flows into UUID-typed DB queries — the direct trigger of the getSystemPrompt ... params: anonymous crash.

• Remove/replace the || "anonymous" fallback in app/actions.tsx (line ~93) so the resolved value is either a real user ID or an explicit null/unauthenticated marker, never the magic string "anonymous".
• Audit and update the other call sites that compare against or produce "anonymous" (e.g., the guards in lib/actions/chat.ts getChat line ~144 and updateDrawingContext line ~230, and any chat-db.ts checks) so they consistently key off a single, well-defined unauthenticated state rather than the string literal.
• Ensure that after this change no DB query can ever receive "anonymous" (or any non-UUID placeholder) as a users.id parameter.

Task 4: Task 1.4: Apply a unified "validate userId before any DB operation" guard pattern

Consolidate the per-call guards (Tasks 1.5, 1.6) into one deliberate, consistent practice per the Assumption 3 policy, rather than ad-hoc fixes.

• Establish a single guard convention: every DB read/write in the resolution-search/submit path (getSystemPrompt, updateDrawingContext, the onSetAIState save, and any other db.* call reachable from submit/processEvents) must first verify the user ID is a genuine authenticated value before issuing the query; if not, it cleanly skips/no-ops (Option 2 of Assumption 3).
• Place the guard check at the top of each DB-dependent function (before any db.select/db.insert) so the context-dependent Next.js cache/tracing wrapper is never entered with an invalid user ID — directly preventing the searchParams undefined / queryWithCache crash.
• Treat this pattern as the unifying contract that Tasks 1.5 and 1.6 implement at specific call sites; document it briefly (code comment / PR note) so future DB-touching actions follow the same checkpoint.

Task 5: Task 1.5: Short-circuit system-prompt lookup for non-authenticated users

Prevent getSystemPrompt from issuing a UUID query with an invalid value (resolves the getSystemPrompt: Failed query ... params: anonymous log).

• Update getSystemPrompt in lib/actions/chat.ts (lines ~274–290) to return null early when the user ID is missing or not a valid authenticated user (mirroring the existing guards in getChat and updateDrawingContext, and following the unified pattern from Task 1.4), avoiding the failed DB query, the Next.js cache-wrapper crash, and the resulting error log.

Task 6: Task 1.6: Make drawing-context and chat persistence fail quietly when unauthenticated

Stop the repeated updateDrawingContext: Invalid or missing user ID and onSetAIState: User not authenticated error spam.

• Update updateDrawingContext in lib/actions/chat.ts (lines ~228–253) so an unauthenticated user ID results in a quiet no-op/skip (returning a benign result, per Task 1.4's guard) rather than an error-level log on every debounced drawing change.
• Optionally guard the client trigger in components/chat.tsx (lines ~104–114) so the debounced save is skipped when there is no authenticated session context.
• Review onSetAIState in app/actions.tsx (lines ~732–794) so the "not authenticated, chat not saved" path uses the threaded userId from Task 1.2 and is treated as an expected, low-severity skip rather than an error.

🤖 Prompt for AI agents

This phase resolves the auth/session context loss (the **auth → DB crash**
failure chain) that causes the user ID to degrade to `"anonymous"` in detached
execution contexts, which in turn crashes `getSystemPrompt` via Next.js's
internal `queryWithCache`/`startActiveSpan` wrapper and spams error logs in
`updateDrawingContext` and `onSetAIState`.

**Task 1.1 — Trace `getCurrentUserIdOnServer()` call sites:**
- Review every call to `getCurrentUserIdOnServer()` in the
resolution-search/submit path: `submit` (`app/actions.tsx` line ~93),
`onSetAIState` (lines ~732–794), and `updateDrawingContext`
(`lib/actions/chat.ts` lines ~228–253).
- Confirm which calls run inside an active Next.js request boundary vs. in
detached/fire-and-forget contexts (e.g., `onSetAIState`, `processEvents()`)
where `cookies()` from `next/headers` is unavailable.
- Add code comments or a PR description note documenting the finding and linking
it to the "first works, subsequent fail" pattern.

**Task 1.2 — `app/actions.tsx` `submit`:**
- Resolve `userId`/session a single time at the very start of `submit` (within
request scope).
- Pass the resolved `userId` explicitly into all downstream consumers:
`getSystemPrompt`, `onSetAIState`'s save path, and any persistence called from
`processEvents()`.
- Ensure the captured `userId` is closed over by lifecycle/fire-and-forget
callbacks so they never re-call `getCurrentUserIdOnServer()` from a detached
context.

**Task 1.3 — Remove the hardcoded `"anonymous"` fallback (`app/actions.tsx` line
~93):**
- Remove/replace the `|| "anonymous"` fallback so the resolved value is either a
real user ID or an explicit `null`/unauthenticated marker, never the magic
string `"anonymous"`.
- Audit and update all other call sites that compare against or produce
`"anonymous"` (e.g., `lib/actions/chat.ts` `getChat` line ~144,
`updateDrawingContext` line ~230, any `chat-db.ts` checks) so they key off a
single, well-defined unauthenticated state.
- Ensure no DB query can ever receive `"anonymous"` (or any non-UUID
placeholder) as a `users.id` parameter.

**Task 1.4 — Unified pre-DB guard pattern:**
- Establish a single guard convention: every DB read/write in the
resolution-search/submit path (`getSystemPrompt`, `updateDrawingContext`, the
`onSetAIState` save, and any other `db.*` call reachable from
`submit`/`processEvents`) must verify the user ID is a genuine authenticated
value at the top of the function, before any `db.select`/`db.insert`; if not,
cleanly skip/no-op.
- Placing the guard before the `db.*` call prevents the Next.js
`queryWithCache`/`startActiveSpan` wrapper from being entered with an invalid
user ID, directly preventing the `searchParams` undefined crash.
- Document this pattern briefly in a code comment or PR note so future
DB-touching actions follow the same checkpoint.

**Task 1.5 — `lib/actions/chat.ts` `getSystemPrompt` (lines ~274–290):**
- Add an early-return guard that returns `null` when the user ID is missing or
not a valid authenticated user.
- Mirror the guard pattern already used in `getChat` and `updateDrawingContext`,
following the unified convention from Task 1.4.

**Task 1.6 — `lib/actions/chat.ts` `updateDrawingContext` (lines ~228–253) and
`app/actions.tsx` `onSetAIState` (lines ~732–794):**
- In `updateDrawingContext`: change the unauthenticated-user handling from an
`error`-level log to a quiet no-op returning a benign result (per Task 1.4's
guard).
- Optionally, in `components/chat.tsx` (lines ~104–114): add a client-side guard
to skip the debounced `updateDrawingContext` call when there is no authenticated
session context.
- In `onSetAIState`: use the threaded `userId` from Task 1.2; change the "not
authenticated, chat not saved" branch from an `error`-level log to a
low-severity skip (e.g., `debug` or `info`).

Phase 2: Repair the Resolution Search Image Pipeline

This phase fixes the image pipeline → API error failure chain: the AI_APICallError: Downloaded response does not contain a valid JPG, PNG, WebP, or ICO image and the misleading Researcher - Image pipeline trace: hasImage: true log. After a resolution search, historical image parts are sanitized to the IMAGE_PROCESSED sentinel, which the message-preparation filter wrongly treats as a valid image and forwards to the xAI vision API — which is why the second request fails after the first seeds the sentinel into AI state. The goal is to ensure only genuine, well-formed image data ever reaches the model.

Task 1: Task 2.1: Strip the sentinel and validate real image content before the model call

Correct the historical-messages filter so only genuine image data survives, and add explicit validation of image URLs/content.

• Update the message-mapping/filter logic in app/actions.tsx (lines ~394–434) so an image part is considered valid only when it is a real data: URL (or a genuine live image URL); the IMAGE_PROCESSED sentinel must be filtered out of the content sent to the model.
• Add an explicit image-content validation step immediately before the agent/model call: assert each remaining { type: 'image' } part contains a non-empty, correctly-formatted image value; drop or reject anything that is not, so no invalid value can reach the xAI API (directly preventing the AI_APICallError).
• Keep the existing diagnostic logging (filteredImagesCount / retainedImagesCount) so the corrected behavior is observable, and log when validation drops a part.

Task 2: Task 2.2: Normalize image-containing messages into proper part arrays

Ensure messages carrying images are always structured as content-part arrays, never plain strings (addresses the lastUserMessageContentStructure: { type: 'string', isArray: false } anomaly seen alongside hasImage: true).

• In app/actions.tsx, add a normalization step in message preparation so any message intended to contain an image is represented as a structured content: [...] array of parts rather than a plain string, keeping text and image parts consistent.
• Ensure that after filtering/validation, messages whose only content was a stripped placeholder retain their remaining text parts and never collapse into a malformed shape; handle empty content arrays gracefully.

Task 3: Task 2.3: Make the researcher's vision-model selection defensive

Guard against any future invalid image part causing a vision model to be selected with unusable content.

• Update the hasImage computation in lib/agents/researcher.tsx (lines ~108–133) so it only counts image parts that contain real image data (a data: URL or live image URL), not sentinel/placeholder strings.
• This ensures getModel(hasImage) is driven by genuinely usable imagery and prevents the trace log from reporting hasImage: true when no real image is present.

🤖 Prompt for AI agents

This phase repairs the resolution search image pipeline so that only genuine
image data reaches the xAI vision API — fixing the `AI_APICallError` that occurs
when the `IMAGE_PROCESSED` sentinel is mistakenly forwarded as a valid image on
subsequent searches.

**Task 2.1 — `app/actions.tsx` (lines ~394–434):**
- Update the message-mapping/filter logic so an image part is only retained if
it contains a real `data:` URL or a genuine live image URL. The
`IMAGE_PROCESSED` sentinel must be filtered out entirely.
- Immediately before the agent/model call, add an explicit validation step that
asserts every remaining `{ type: 'image' }` part has a non-empty,
correctly-formatted image value; drop any part that does not pass.
- Retain and update the existing `filteredImagesCount` / `retainedImagesCount`
diagnostic logging to reflect the new behavior; add a log entry when the
validation step drops a part.

**Task 2.2 — `app/actions.tsx` message normalization:**
- Add a normalization step in message preparation so any message carrying an
image is represented as a structured `content: [...]` array of parts (not a
plain string).
- After filtering/validation, ensure messages whose only content was a stripped
placeholder retain their remaining text parts and are never left with an empty
content array; handle this edge case gracefully.

**Task 2.3 — `lib/agents/researcher.tsx` (lines ~108–133):**
- Update the `hasImage` computation so only image parts containing real image
data (a `data:` URL or a live image URL) are counted — sentinel/placeholder
strings like `IMAGE_PROCESSED` must not be counted.
- This prevents `hasImage` from being `true` when no usable image is present,
avoiding incorrect vision-model selection via `getModel(hasImage)`.

Phase 3: Harden Server-Side Streaming, Timeouts, and Resilience

This phase addresses the missing error handling → timeout failure chain: the "page refreshes" / Vercel Runtime Timeout Error: Task timed out after 60 seconds symptom, and ensures subsequent requests recover cleanly. Currently the AI_APICallError thrown inside researcher() propagates into the fire-and-forget processEvents() with no try/catch, leaving the uiStream unclosed so the client stalls until timeout, and leaving AI state in a state that breaks the next request.

Task 1: Task 3.1: Catch agent failures and finalize the stream

Ensure the researcher/resolution-search flow never leaves a dangling open stream (resolves the 60-second timeout).

• Wrap the streamText/agent invocation in lib/agents/researcher.tsx (and the equivalent call site in processEvents within app/actions.tsx) in error handling so that an AI_APICallError (or any agent error) is caught, the uiStream/summaryStream are properly completed (.done() / .error()), and an error indicator is written instead of leaving the stream open until timeout.
• Make sure the AI state is finalized appropriately on the error path so the next request starts from a clean history.

Task 2: Task 3.2: Ensure subsequent requests recover after a failure

Address the "subsequent ones don't work" pattern at the state level, not just the stream level.

• After any error in processEvents()/agent flow, ensure AI state is left without lingering invalid image parts or partial messages that would re-trigger the same AI_APICallError on the next attempt (coordinating with Phase 2's sentinel stripping).
• Verify that a failed resolution search does not block or corrupt a follow-up search — the isAnalyzing reset in resolution-carousel.tsx plus clean AI-state finalization should allow immediate retry.
• Consider explicitly bounding long-running agent work so it fails fast with a surfaced error rather than silently approaching the Vercel 60s limit.

Task 3: Task 3.3: Provide consistent client-visible error feedback

Ensure failures present a clear message rather than a silent stall or implicit refresh.

• Confirm/extend error handling at the client entry points — components/chat-panel.tsx handleSubmit (which currently has no try/catch) and the already-handled components/resolution-carousel.tsx handleQCXAnalysis — so a failed submit surfaces a toast/error state rather than an unhandled rejection, matching the existing toast pattern used in the carousel.

🤖 Prompt for AI agents

This phase prevents the 60-second Vercel timeout and page-refresh symptom by
ensuring agent failures always close the UI stream, surface a clean error to the
client, and leave AI state in a recoverable shape for subsequent requests.

**Task 3.1 — `lib/agents/researcher.tsx` and `app/actions.tsx`
`processEvents`:**
- Wrap the `streamText`/agent invocation in `lib/agents/researcher.tsx` with a
try/catch block.
- On catch: call `.done()` or `.error()` on the `uiStream`/`summaryStream` to
close them, write an error indicator to the stream, and finalize AI state so the
next request starts from a clean history.
- Apply the same try/catch pattern to the equivalent call site in
`processEvents` inside `app/actions.tsx`.
- Key invariant: the stream must always be finalized (success or error) — it
must never be left open until the Vercel function times out.

**Task 3.2 — `app/actions.tsx` `processEvents` and
`components/resolution-carousel.tsx`:**
- After any error in the agent/`processEvents()` flow, ensure AI state is
finalized without lingering invalid image parts or partial messages that would
re-trigger the same `AI_APICallError` on the next attempt.
- Verify `isAnalyzing` is reset in `resolution-carousel.tsx` on the error path
so immediate retry is possible.
- Consider adding an explicit timeout bound on long-running agent work so it
fails fast with a surfaced error rather than silently approaching the Vercel 60s
limit.

**Task 3.3 — `components/chat-panel.tsx` `handleSubmit`:**
- Add a try/catch around the submit invocation in `handleSubmit` (currently has
no error handling).
- On catch, surface the error as a toast/error state matching the existing toast
pattern in `components/resolution-carousel.tsx` `handleQCXAnalysis`.
- Confirm that `components/resolution-carousel.tsx` `handleQCXAnalysis` already
handles this correctly; extend or align if needed.

Phase 4: Reproduce and Verify the "First Works, Subsequent Fail" Fix

This phase confirms the three interacting root causes are actually resolved across repeated actions, since the defining symptom is intermittent and sequence-dependent.

Task 1: Task 4.1: Reproduce the failure sequence before and after the fix

Create a deterministic repro for the regression.

• Reproduce the original sequence: run one successful resolution search, then run a second/third — confirming the pre-fix behavior produces the AI_APICallError, the getSystemPrompt ... params: anonymous crash, and the 60s timeout on the later attempts.
• After applying Phases 1–3, repeat the same sequence and confirm subsequent searches succeed, no IMAGE_PROCESSED value reaches the API, and no timeout occurs.

Task 2: Task 4.2: Verify session persistence and clean logs across repeated actions

Confirm the auth root cause is fixed, not just masked.

• Verify that across repeated resolution searches and drawing-context saves the resolved userId remains stable (no degradation to "anonymous"), and that getSystemPrompt, updateDrawingContext, and onSetAIState no longer emit error-level logs for authenticated sessions.
• Verify the unauthenticated path now short-circuits cleanly (benign skips, no DB crash) and that the Researcher - Image pipeline trace reports hasImage correctly relative to actual image content.

🤖 Prompt for AI agents

This phase is a verification/QA phase to confirm all three interacting root
causes are resolved across repeated actions. No new code is written; the goal is
to exercise the fixed flows and validate behavior.

**Task 4.1 — Reproduce the failure sequence:**
- Run the original failure sequence manually (or via test): one successful
resolution search, then a second/third attempt.
- Before the fix: confirm the `AI_APICallError`, `getSystemPrompt ... params:
anonymous` crash, and 60s timeout are reproduced on subsequent attempts.
- After applying Phases 1–3: repeat the sequence and confirm subsequent searches
succeed, no `IMAGE_PROCESSED` value reaches the API, and no timeout occurs.

**Task 4.2 — Verify session and log cleanliness:**
- Across repeated resolution searches and drawing-context saves, confirm the
resolved `userId` remains stable and never degrades to `"anonymous"`.
- Confirm `getSystemPrompt`, `updateDrawingContext`, and `onSetAIState` no
longer emit error-level logs for authenticated sessions.
- Confirm the unauthenticated path short-circuits cleanly with benign skips and
no DB crash.
- Confirm the `Researcher - Image pipeline trace` reports `hasImage` correctly
relative to actual image content present in the request.

Research

This is a Next.js 15 application using the Vercel AI RSC (ai/rsc) pattern. The resolution-search feature lets users capture map imagery (Mapbox + Google Satellite) and run a vision-model analysis. The flow runs through the submit server action in app/actions.tsx, which resolves the user via cookie-based Supabase SSR auth (lib/auth/get-current-user.ts), prepares message history, calls AI agents (lib/agents/researcher.tsx, lib/agents/resolution-search.tsx), streams UI back, and persists state. DB access is a plain Drizzle + pg pool (lib/db/index.ts) with no project-level caching; the queryWithCache/startActiveSpan frames in the logs are Next.js's own internal instrumentation wrapping the query. After a resolution search, image parts in AI state are replaced with an IMAGE_PROCESSED sentinel to avoid storing large base64 blobs. The string "anonymous" is a hardcoded fallback applied at the call site in submit (app/actions.tsx line ~93) when getCurrentUserIdOnServer() returns null, and it is the value that crashes the UUID-typed getSystemPrompt query.

---

🚀 Next Steps

🤖 All AI agent prompts combined

Task: 1

This phase resolves the auth/session context loss (the **auth → DB crash**
failure chain) that causes the user ID to degrade to `"anonymous"` in detached
execution contexts, which in turn crashes `getSystemPrompt` via Next.js's
internal `queryWithCache`/`startActiveSpan` wrapper and spams error logs in
`updateDrawingContext` and `onSetAIState`.

**Task 1.1 — Trace `getCurrentUserIdOnServer()` call sites:**
- Review every call to `getCurrentUserIdOnServer()` in the
resolution-search/submit path: `submit` (`app/actions.tsx` line ~93),
`onSetAIState` (lines ~732–794), and `updateDrawingContext`
(`lib/actions/chat.ts` lines ~228–253).
- Confirm which calls run inside an active Next.js request boundary vs. in
detached/fire-and-forget contexts (e.g., `onSetAIState`, `processEvents()`)
where `cookies()` from `next/headers` is unavailable.
- Add code comments or a PR description note documenting the finding and linking
it to the "first works, subsequent fail" pattern.

**Task 1.2 — `app/actions.tsx` `submit`:**
- Resolve `userId`/session a single time at the very start of `submit` (within
request scope).
- Pass the resolved `userId` explicitly into all downstream consumers:
`getSystemPrompt`, `onSetAIState`'s save path, and any persistence called from
`processEvents()`.
- Ensure the captured `userId` is closed over by lifecycle/fire-and-forget
callbacks so they never re-call `getCurrentUserIdOnServer()` from a detached
context.

**Task 1.3 — Remove the hardcoded `"anonymous"` fallback (`app/actions.tsx` line
~93):**
- Remove/replace the `|| "anonymous"` fallback so the resolved value is either a
real user ID or an explicit `null`/unauthenticated marker, never the magic
string `"anonymous"`.
- Audit and update all other call sites that compare against or produce
`"anonymous"` (e.g., `lib/actions/chat.ts` `getChat` line ~144,
`updateDrawingContext` line ~230, any `chat-db.ts` checks) so they key off a
single, well-defined unauthenticated state.
- Ensure no DB query can ever receive `"anonymous"` (or any non-UUID
placeholder) as a `users.id` parameter.

**Task 1.4 — Unified pre-DB guard pattern:**
- Establish a single guard convention: every DB read/write in the
resolution-search/submit path (`getSystemPrompt`, `updateDrawingContext`, the
`onSetAIState` save, and any other `db.*` call reachable from
`submit`/`processEvents`) must verify the user ID is a genuine authenticated
value at the top of the function, before any `db.select`/`db.insert`; if not,
cleanly skip/no-op.
- Placing the guard before the `db.*` call prevents the Next.js
`queryWithCache`/`startActiveSpan` wrapper from being entered with an invalid
user ID, directly preventing the `searchParams` undefined crash.
- Document this pattern briefly in a code comment or PR note so future
DB-touching actions follow the same checkpoint.

**Task 1.5 — `lib/actions/chat.ts` `getSystemPrompt` (lines ~274–290):**
- Add an early-return guard that returns `null` when the user ID is missing or
not a valid authenticated user.
- Mirror the guard pattern already used in `getChat` and `updateDrawingContext`,
following the unified convention from Task 1.4.

**Task 1.6 — `lib/actions/chat.ts` `updateDrawingContext` (lines ~228–253) and
`app/actions.tsx` `onSetAIState` (lines ~732–794):**
- In `updateDrawingContext`: change the unauthenticated-user handling from an
`error`-level log to a quiet no-op returning a benign result (per Task 1.4's
guard).
- Optionally, in `components/chat.tsx` (lines ~104–114): add a client-side guard
to skip the debounced `updateDrawingContext` call when there is no authenticated
session context.
- In `onSetAIState`: use the threaded `userId` from Task 1.2; change the "not
authenticated, chat not saved" branch from an `error`-level log to a
low-severity skip (e.g., `debug` or `info`).
===============================================================================

Task: 2

This phase repairs the resolution search image pipeline so that only genuine
image data reaches the xAI vision API — fixing the `AI_APICallError` that occurs
when the `IMAGE_PROCESSED` sentinel is mistakenly forwarded as a valid image on
subsequent searches.

**Task 2.1 — `app/actions.tsx` (lines ~394–434):**
- Update the message-mapping/filter logic so an image part is only retained if
it contains a real `data:` URL or a genuine live image URL. The
`IMAGE_PROCESSED` sentinel must be filtered out entirely.
- Immediately before the agent/model call, add an explicit validation step that
asserts every remaining `{ type: 'image' }` part has a non-empty,
correctly-formatted image value; drop any part that does not pass.
- Retain and update the existing `filteredImagesCount` / `retainedImagesCount`
diagnostic logging to reflect the new behavior; add a log entry when the
validation step drops a part.

**Task 2.2 — `app/actions.tsx` message normalization:**
- Add a normalization step in message preparation so any message carrying an
image is represented as a structured `content: [...]` array of parts (not a
plain string).
- After filtering/validation, ensure messages whose only content was a stripped
placeholder retain their remaining text parts and are never left with an empty
content array; handle this edge case gracefully.

**Task 2.3 — `lib/agents/researcher.tsx` (lines ~108–133):**
- Update the `hasImage` computation so only image parts containing real image
data (a `data:` URL or a live image URL) are counted — sentinel/placeholder
strings like `IMAGE_PROCESSED` must not be counted.
- This prevents `hasImage` from being `true` when no usable image is present,
avoiding incorrect vision-model selection via `getModel(hasImage)`.
===============================================================================

Task: 3

This phase prevents the 60-second Vercel timeout and page-refresh symptom by
ensuring agent failures always close the UI stream, surface a clean error to the
client, and leave AI state in a recoverable shape for subsequent requests.

**Task 3.1 — `lib/agents/researcher.tsx` and `app/actions.tsx`
`processEvents`:**
- Wrap the `streamText`/agent invocation in `lib/agents/researcher.tsx` with a
try/catch block.
- On catch: call `.done()` or `.error()` on the `uiStream`/`summaryStream` to
close them, write an error indicator to the stream, and finalize AI state so the
next request starts from a clean history.
- Apply the same try/catch pattern to the equivalent call site in
`processEvents` inside `app/actions.tsx`.
- Key invariant: the stream must always be finalized (success or error) — it
must never be left open until the Vercel function times out.

**Task 3.2 — `app/actions.tsx` `processEvents` and
`components/resolution-carousel.tsx`:**
- After any error in the agent/`processEvents()` flow, ensure AI state is
finalized without lingering invalid image parts or partial messages that would
re-trigger the same `AI_APICallError` on the next attempt.
- Verify `isAnalyzing` is reset in `resolution-carousel.tsx` on the error path
so immediate retry is possible.
- Consider adding an explicit timeout bound on long-running agent work so it
fails fast with a surfaced error rather than silently approaching the Vercel 60s
limit.

**Task 3.3 — `components/chat-panel.tsx` `handleSubmit`:**
- Add a try/catch around the submit invocation in `handleSubmit` (currently has
no error handling).
- On catch, surface the error as a toast/error state matching the existing toast
pattern in `components/resolution-carousel.tsx` `handleQCXAnalysis`.
- Confirm that `components/resolution-carousel.tsx` `handleQCXAnalysis` already
handles this correctly; extend or align if needed.
===============================================================================

Task: 4

This phase is a verification/QA phase to confirm all three interacting root
causes are resolved across repeated actions. No new code is written; the goal is
to exercise the fixed flows and validate behavior.

**Task 4.1 — Reproduce the failure sequence:**
- Run the original failure sequence manually (or via test): one successful
resolution search, then a second/third attempt.
- Before the fix: confirm the `AI_APICallError`, `getSystemPrompt ... params:
anonymous` crash, and 60s timeout are reproduced on subsequent attempts.
- After applying Phases 1–3: repeat the sequence and confirm subsequent searches
succeed, no `IMAGE_PROCESSED` value reaches the API, and no timeout occurs.

**Task 4.2 — Verify session and log cleanliness:**
- Across repeated resolution searches and drawing-context saves, confirm the
resolved `userId` remains stable and never degrades to `"anonymous"`.
- Confirm `getSystemPrompt`, `updateDrawingContext`, and `onSetAIState` no
longer emit error-level logs for authenticated sessions.
- Confirm the unauthenticated path short-circuits cleanly with benign skips and
no DB crash.
- Confirm the `Researcher - Image pipeline trace` reports `hasImage` correctly
relative to actual image content present in the request.

💡 Iterate on the plan with: `@coderabbitai` <feedback>

Example Feedback
- `@coderabbitai` You can skip phase 3. Add a simple unit test case for phase 2.
- `@coderabbitai` For design choice 1 go ahead with option 3 and replan.

---

💬 Have feedback or questions? Drop into our discord!

[coderabbitai]

@ngoiyaeric Yes — I did take that input into account.

Your notes are reflected in the plan like this:

• Hardcoded anonymous user ID in app/actions.tsx at Line 491
  → covered in Phase 2, especially the getSystemPrompt guard and auth short-circuiting.

• getSystemPrompt(userId) failing on non-UUID input
  → covered in Task 2.1 to return early for missing / "anonymous" users.

• updateDrawingContext failing for unauthenticated users
  → covered in Task 2.2 to make that path a quiet no-op instead of noisy failure logging.

• onSetAIState not saving chats when unauthenticated
  → covered in Task 2.3 to treat that as an expected skip, not an error.

• Image pipeline mismatch / invalid image content reaching xAI
  → covered in Phase 1, especially stripping the IMAGE_PROCESSED sentinel and making hasImage validate real image payloads.

• Page refresh / timeout symptom
  → covered in Phase 3 by hardening stream finalization so agent failures don’t leave the UI stream hanging.

One nuance: I treated the image pipeline + unclosed stream as the most likely cause of the actual timeout/page-refresh behavior, and the auth / anonymous UUID issue as a separate but real failure that adds error noise and breaks persistence-related paths.

If you want, I can also reorder the plan so it starts with the auth fix first, since that was the main focus of your input.
(•ᵕ•)૭

---

✏️ Learnings added

Learnt from: ngoiyaeric
URL: https://github.com/QueueLab/QCX/issues/688

Timestamp: 2026-06-26T12:44:56.557Z
Learning: In QueueLab/QCX, `app/actions.tsx` uses a hardcoded `'anonymous'` user ID when fetching the system prompt, while `lib/actions/chat.ts` `getSystemPrompt(userId: string)` queries a UUID-backed users table; future reviews should guard against passing `'anonymous'` or other non-authenticated sentinel values into database lookups that expect valid user IDs.

---

Learnt from: ngoiyaeric
URL: https://github.com/QueueLab/QCX/issues/688

Timestamp: 2026-06-26T12:44:56.557Z
Learning: In QueueLab/QCX, the resolution-search flow can replace stored image parts with an `IMAGE_PROCESSED` sentinel, and `lib/agents/researcher.tsx` should not treat every `part.type === 'image'` as usable image input; future reviews should validate that image parts contain real payloads/URLs before selecting vision models or forwarding them to the xAI API.

Note: Learnings are effective only in the context of similar code segments. To apply general coding guidelines, please configure review instructions. You can manage existing learnings in the app.