perf(search): fetch Lucid page regions concurrently on a live read

A Lucid read made about 11 MCP calls in sequence: metadata, a metadata-only
manifest, one fetch per page region (up to 8), then metadata again. At 1-2 s
per call that ran past the 15 s live read deadline. The first metadata and
manifest now run together, and region fetches run four at a time. Their
validation still walks them in page and region order, and the before/after
change checks are unchanged.

Author: waleedlatif1

apps/sim/lib/sim-search/live/lucid-mcp.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, it } from 'vitest'
+import { readLucidMcp } from '@/lib/sim-search/live/lucid-mcp'
+import type { ManagedSearchMcpClient } from '@/lib/sim-search/live/managed-mcp'
+
+const ID = '0b6a3f0e-5a52-4c55-9d8c-6d2f2a1b9c11'
+const COUNTS = [2, 1]
+const metadataRow = {
+  documentId: ID,
+  viewUrl: `https://lucid.app/lucidchart/${ID}/view`,
+  product: 'lucidchart',
+  title: 'Fixture diagram',
+  version: 7,
+  pageCount: COUNTS.length,
+  lastModified: '2026-10-01T12:00:00Z',
+}
+
+function manifest(extra: Record<string, unknown> = {}) {
+  return {
+    document_id: ID,
+    edit_url: `https://lucid.app/lucidchart/${ID}/edit`,
+    title: 'Fixture diagram',
+    metadata: { page_count: COUNTS.length, page_region_counts: COUNTS, ...extra },
+  }
+}
+
+function regionResponse(pageIndex: number, region: number) {
+  const pageId = `page-${pageIndex}`
+  return {
+    ...manifest({ page_index: pageIndex + 1 }),
+    page_index: pageIndex + 1,
+    page_id: pageId,
+    text: JSON.stringify({
+      pages: [
+        {
+          pageIndex,
+          pageId,
+          pageTitle: `Page ${pageIndex + 1}`,
+          totalChunks: COUNTS[pageIndex],
+          requestedChunks: [{ chunkIndex: region, data: { label: `p${pageIndex}r${region}` } }],
+        },
+      ],
+    }),
+  }
+}
+
+/** Region fetches settle in reverse request order, after a number of ticks, to expose ordering. */
+function lucidClient() {
+  let inFlight = 0
+  let maxInFlight = 0
+  let regionCalls = 0
+  const client: ManagedSearchMcpClient = {
+    async call(name, args) {
+      if (name === 'lucid_get_document_metadata') return metadataRow
+      if (args.metadata_only) return manifest()
+      const pageIndex = Number(args.page_index) - 1
+      const region = Array.isArray(args.region_index) ? Number(args.region_index[0]) - 1 : 0
+      const delay = 10 - regionCalls++
+      inFlight++
+      maxInFlight = Math.max(maxInFlight, inFlight)
+      for (let tick = 0; tick < delay; tick++) await Promise.resolve()
+      inFlight--
+      return regionResponse(pageIndex, region)
+    },
+  }
+  return { client, maxInFlight: () => maxInFlight }
+}
+
+describe('readLucidMcp', () => {
+  it('fetches page regions concurrently and assembles them in page and region order', async () => {
+    const { client, maxInFlight } = lucidClient()
+    const document = await readLucidMcp(client, { id: ID, kind: 'lucidchart', revision: '7' })
+    expect(maxInFlight()).toBeGreaterThan(1)
+    const pages = JSON.parse(document.content ?? '').pages as {
+      pageId: string
+      requestedChunks: { data: { label: string } }[]
+    }[]
+    expect(pages.map((page) => page.pageId)).toEqual(['page-0', 'page-1'])
+    expect(pages.map((page) => page.requestedChunks.map((chunk) => chunk.data.label))).toEqual([
+      ['p0r0', 'p0r1'],
+      ['p1r0'],
+    ])
+  })
+})

apps/sim/lib/sim-search/live/lucid-mcp.ts

@@ -322,44 +322,52 @@ function manifest(value: unknown, id: string, kind: string | undefined) {
   return { row, counts: counts as number[] }
 }
 
+/**
+ * Region fetches are independent provider reads; running them together keeps a full read inside
+ * the live read deadline. Validation still walks them in page and region order.
+ */
+const REGION_FETCH_CONCURRENCY = 4
+
 /** Complete, bounded provider pages preserve graph data; no returned URL is fetched. */
 export async function readLucidMcp(
   client: ManagedSearchMcpClient,
   reference: Pick<NativeDocument, 'id' | 'kind' | 'revision'>
 ): Promise<NativeDocument> {
-  const before = await metadata(client, reference.id)
+  const [before, initialRaw] = await Promise.all([
+    metadata(client, reference.id),
+    client.call('fetch', { id: reference.id, metadata_only: true }),
+  ])
   if (!before) invalid('Lucid document metadata is incomplete or no longer readable.')
   if (
     (reference.kind && reference.kind !== before.kind) ||
     (reference.revision && reference.revision !== before.revision)
   )
     invalid('Lucid document changed since this result was issued. Search again before reading.')
-  const initial = manifest(
-    await client.call('fetch', { id: before.id, metadata_only: true }),
-    before.id,
-    before.kind
-  )
+  const initial = manifest(initialRaw, before.id, before.kind)
   if (
     initial.counts.length !== before.accessMetadata?.pageCount ||
     initial.row.title !== before.title
   )
     invalid('Lucid document coverage changed before reading. Search again.')
   const pages: Record<string, unknown>[] = []
   const output = () => JSON.stringify({ document_id: before.id, title: before.title, pages })
+  const requests = initial.counts.flatMap((count, pageIndex) =>
+    Array.from({ length: Math.max(1, count) }, (_, region) => ({ pageIndex, region, count }))
+  )
+  const responses = await mapWithConcurrency(requests, REGION_FETCH_CONCURRENCY, (request) =>
+    client.call('fetch', {
+      id: before.id,
+      page_index: request.pageIndex + 1,
+      ...(request.count ? { region_index: [request.region + 1] } : {}),
+    })
+  )
+  let next = 0
   for (let pageIndex = 0; pageIndex < initial.counts.length; pageIndex++) {
-    const count = initial.counts[pageIndex]!
+    const count = initial.counts[pageIndex] ?? 0
     let assembled: Record<string, unknown> | undefined
     const chunks: Record<string, unknown>[] = []
     for (let region = 0; region < Math.max(1, count); region++) {
-      const fetched = manifest(
-        await client.call('fetch', {
-          id: before.id,
-          page_index: pageIndex + 1,
-          ...(count ? { region_index: [region + 1] } : {}),
-        }),
-        before.id,
-        before.kind
-      )
+      const fetched = manifest(responses[next++], before.id, before.kind)
       if (
         fetched.counts.some((value, index) => value !== initial.counts[index]) ||
         fetched.counts.length !== initial.counts.length ||