@open-mercato/ai-assistant 0.7.0 → 0.7.1-develop.7103.1.41ff100d93

package/src/modules/ai_assistant/__tests__/integration/ws-c-tool-pack-coverage.test.ts

@@ -156,10 +156,15 @@ describe('WS-C integration — tool-pack coverage', () => {
 
     it('propagates tenantId + organizationId to the search service call', async () => {
       const searchMock = jest.fn().mockResolvedValue([])
+      const searchIndexerMock = {
+        getEntityConfig: (entityId: string) => ({ entityId, aclFeatures: ['ai_assistant.view'], enabled: true } as any),
+        getAllEntityConfigs: () => [{ entityId: 'test:entity', aclFeatures: ['ai_assistant.view'], enabled: true } as any],
+      }
       const ctx = makeCtx({
         container: {
           resolve: (name: string) => {
             if (name === 'searchService') return { search: searchMock }
+            if (name === 'searchIndexer') return searchIndexerMock
             throw new Error(`Unknown registration: ${name}`)
           },
         },

package/src/modules/ai_assistant/ai-tools/__tests__/search-pack.test.ts

@@ -2,7 +2,8 @@
  * Step 3.8 — `search.*` tool pack unit tests.
  *
  * Covers `search.hybrid_search` happy path and `search.get_record_context`
- * happy / miss / tenant isolation.
+ * happy / miss / tenant isolation, plus per-entity ACL enforcement for
+ * issue #5211 (legacy pack must not leak records the caller cannot view).
  */
 import searchAiTools from '../search-pack'
 
@@ -57,6 +58,19 @@ function makeSearchService(results: unknown[]): {
   }
 }
 
+function makeLookup(configs: Array<{ entityId: string; aclFeatures?: string[]; enabled?: boolean }>) {
+  const map = new Map(configs.map((c) => [c.entityId, c]))
+  return {
+    getEntityConfig: (entityId: string) => map.get(entityId) as any,
+    getAllEntityConfigs: () => configs as any,
+  }
+}
+
+function permissiveLookup(entityIds: string[] = ['catalog:product']) {
+  const configs = entityIds.map((id) => ({ entityId: id, aclFeatures: ['search.view'], enabled: true }))
+  return makeLookup(configs)
+}
+
 describe('search.hybrid_search', () => {
   const tool = findTool('search.hybrid_search')
 
@@ -71,8 +85,10 @@ describe('search.hybrid_search', () => {
       },
     ])
     const ctx = makeCtx()
+    const lookup = permissiveLookup(['catalog:product'])
     ;(ctx.container.resolve as jest.Mock).mockImplementation((name: string) => {
       if (name === 'searchService') return service
+      if (name === 'searchIndexer') return lookup
       throw new Error(`unexpected resolve ${name}`)
     })
     const result = (await tool.handler(
@@ -95,7 +111,12 @@ describe('search.hybrid_search', () => {
   it('defaults limit to 20 when omitted', async () => {
     const { service, calls } = makeSearchService([])
     const ctx = makeCtx()
-    ;(ctx.container.resolve as jest.Mock).mockReturnValue(service)
+    const lookup = permissiveLookup(['catalog:product'])
+    ;(ctx.container.resolve as jest.Mock).mockImplementation((name: string) => {
+      if (name === 'searchService') return service
+      if (name === 'searchIndexer') return lookup
+      return undefined
+    })
     await tool.handler({ q: 'hello' }, ctx as any)
     expect(calls[0].options.limit).toBe(20)
   })
@@ -105,6 +126,105 @@ describe('search.hybrid_search', () => {
     ;(ctx.container.resolve as jest.Mock).mockReturnValue({ search: jest.fn() })
     await expect(tool.handler({ q: 'x' }, ctx as any)).rejects.toThrow(/Tenant context/)
   })
+
+  it('withholds results for entity types the caller cannot view', async () => {
+    const lookup = makeLookup([
+      { entityId: 'customers:customer_person_profile', aclFeatures: ['customers.people.view'], enabled: true },
+      { entityId: 'catalog:catalog_product', aclFeatures: ['catalog.products.view'], enabled: true },
+    ])
+    const { service, calls } = makeSearchService([
+      { entityId: 'customers:customer_person_profile', recordId: 'p1', score: 0.9, source: 'fulltext', presenter: { title: 'Person' } },
+      { entityId: 'catalog:catalog_product', recordId: 'c1', score: 0.8, source: 'fulltext', presenter: { title: 'Product' } },
+    ])
+    const ctx = makeCtx({ userFeatures: ['search.view', 'customers.people.view'] })
+    ;(ctx.container.resolve as jest.Mock).mockImplementation((name: string) => {
+      if (name === 'searchService') return service
+      if (name === 'searchIndexer') return lookup
+      throw new Error(`unexpected resolve ${name}`)
+    })
+    const result = (await tool.handler({ q: 'test' }, ctx as any)) as Record<string, unknown>
+    // Should have narrowed entityTypes to only readable type
+    expect((calls[0].options as any).entityTypes).toEqual(['customers:customer_person_profile'])
+    // Defense in depth: results filtered to only readable
+    expect(result.totalResults).toBe(1)
+    expect((result.results as any[])[0].entityId).toBe('customers:customer_person_profile')
+  })
+
+  it('short-circuits without calling search when no entity type is readable for an explicit request', async () => {
+    const lookup = makeLookup([
+      { entityId: 'catalog:catalog_product', aclFeatures: ['catalog.products.view'], enabled: true },
+    ])
+    const { service, calls } = makeSearchService([
+      { entityId: 'catalog:catalog_product', recordId: 'c1', score: 0.8, source: 'fulltext' },
+    ])
+    const ctx = makeCtx({ userFeatures: ['search.view'] })
+    ;(ctx.container.resolve as jest.Mock).mockImplementation((name: string) => {
+      if (name === 'searchService') return service
+      if (name === 'searchIndexer') return lookup
+      throw new Error(`unexpected ${name}`)
+    })
+    const result = (await tool.handler({ q: 'test', entityTypes: ['catalog:catalog_product'] }, ctx as any)) as Record<string, unknown>
+    expect(calls).toHaveLength(0)
+    expect(result.totalResults).toBe(0)
+    expect(result.results).toEqual([])
+  })
+
+  it('intersects an explicitly requested mixed set with the readable set', async () => {
+    const lookup = makeLookup([
+      { entityId: 'customers:customer_person_profile', aclFeatures: ['customers.people.view'], enabled: true },
+      { entityId: 'catalog:catalog_product', aclFeatures: ['catalog.products.view'], enabled: true },
+      { entityId: 'secret:thing', aclFeatures: ['secret.view'], enabled: true },
+    ])
+    const { service, calls } = makeSearchService([
+      { entityId: 'customers:customer_person_profile', recordId: 'p1', score: 0.9, source: 'fulltext' },
+      { entityId: 'catalog:catalog_product', recordId: 'c1', score: 0.8, source: 'fulltext' },
+    ])
+    const ctx = makeCtx({ userFeatures: ['search.view', 'customers.people.view'] })
+    ;(ctx.container.resolve as jest.Mock).mockImplementation((name: string) => {
+      if (name === 'searchService') return service
+      if (name === 'searchIndexer') return lookup
+      throw new Error(`unexpected ${name}`)
+    })
+    await tool.handler({ q: 'test', entityTypes: ['customers:customer_person_profile', 'catalog:catalog_product', 'secret:thing'] }, ctx as any)
+    expect((calls[0].options as any).entityTypes).toEqual(['customers:customer_person_profile'])
+  })
+
+  it('drops results a strategy returned for an unreadable entity type (defense in depth)', async () => {
+    const lookup = makeLookup([
+      { entityId: 'customers:customer_person_profile', aclFeatures: ['customers.people.view'], enabled: true },
+      { entityId: 'secret:thing', aclFeatures: ['secret.view'], enabled: true },
+    ])
+    const { service } = makeSearchService([
+      { entityId: 'customers:customer_person_profile', recordId: 'p1', score: 0.9, source: 'fulltext' },
+      { entityId: 'secret:thing', recordId: 's1', score: 0.8, source: 'fulltext' },
+    ])
+    const ctx = makeCtx({ userFeatures: ['search.view', 'customers.people.view'] })
+    ;(ctx.container.resolve as jest.Mock).mockImplementation((name: string) => {
+      if (name === 'searchService') return service
+      if (name === 'searchIndexer') return lookup
+      throw new Error(`unexpected ${name}`)
+    })
+    const result = (await tool.handler({ q: 'test' }, ctx as any)) as Record<string, unknown>
+    expect((result.results as any[]).every((r: any) => r.entityId === 'customers:customer_person_profile')).toBe(true)
+  })
+
+  it('allows a superadmin to see all requested entity types', async () => {
+    const lookup = makeLookup([
+      { entityId: 'secret:thing', aclFeatures: ['secret.view'], enabled: true },
+    ])
+    const { service, calls } = makeSearchService([
+      { entityId: 'secret:thing', recordId: 's1', score: 0.8, source: 'fulltext' },
+    ])
+    const ctx = makeCtx({ userFeatures: [], isSuperAdmin: true })
+    ;(ctx.container.resolve as jest.Mock).mockImplementation((name: string) => {
+      if (name === 'searchService') return service
+      if (name === 'searchIndexer') return lookup
+      throw new Error(`unexpected ${name}`)
+    })
+    const result = (await tool.handler({ q: 'test', entityTypes: ['secret:thing'] }, ctx as any)) as Record<string, unknown>
+    expect(calls[0].options.entityTypes).toEqual(['secret:thing'])
+    expect(result.totalResults).toBe(1)
+  })
 })
 
 describe('search.get_record_context', () => {
@@ -125,7 +245,12 @@ describe('search.get_record_context', () => {
       match,
     ])
     const ctx = makeCtx()
-    ;(ctx.container.resolve as jest.Mock).mockReturnValue(service)
+    const lookup = permissiveLookup(['catalog:product'])
+    ;(ctx.container.resolve as jest.Mock).mockImplementation((name: string) => {
+      if (name === 'searchService') return service
+      if (name === 'searchIndexer') return lookup
+      throw new Error(`unexpected ${name}`)
+    })
     const result = (await tool.handler(
       { entityId: 'catalog:product', recordId: 'rec-42' },
       ctx as any,
@@ -149,7 +274,12 @@ describe('search.get_record_context', () => {
       { entityId: 'catalog:product', recordId: 'other', score: 0.2, source: 'fulltext' },
     ])
     const ctx = makeCtx()
-    ;(ctx.container.resolve as jest.Mock).mockReturnValue(service)
+    const lookup = permissiveLookup(['catalog:product'])
+    ;(ctx.container.resolve as jest.Mock).mockImplementation((name: string) => {
+      if (name === 'searchService') return service
+      if (name === 'searchIndexer') return lookup
+      throw new Error(`unexpected ${name}`)
+    })
     const result = (await tool.handler(
       { entityId: 'catalog:product', recordId: 'missing' },
       ctx as any,
@@ -161,7 +291,12 @@ describe('search.get_record_context', () => {
   it('passes the caller tenant/org and never leaks another tenant', async () => {
     const { service, calls } = makeSearchService([])
     const ctx = makeCtx({ tenantId: 'tenant-A', organizationId: 'org-A' })
-    ;(ctx.container.resolve as jest.Mock).mockReturnValue(service)
+    const lookup = permissiveLookup(['x:y'])
+    ;(ctx.container.resolve as jest.Mock).mockImplementation((name: string) => {
+      if (name === 'searchService') return service
+      if (name === 'searchIndexer') return lookup
+      throw new Error(`unexpected ${name}`)
+    })
     await tool.handler({ entityId: 'x:y', recordId: 'z' }, ctx as any)
     expect(calls[0].options).toMatchObject({
       tenantId: 'tenant-A',
@@ -177,6 +312,77 @@ describe('search.get_record_context', () => {
       tool.handler({ entityId: 'x:y', recordId: 'z' }, ctx as any),
     ).rejects.toThrow(/Tenant context/)
   })
+
+  it('rejects an explicitly requested unauthorized entity type', async () => {
+    const lookup = makeLookup([
+      { entityId: 'customers:customer_person_profile', aclFeatures: ['customers.people.view'], enabled: true },
+    ])
+    const { service } = makeSearchService([])
+    const ctx = makeCtx({ userFeatures: ['search.view'] })
+    ;(ctx.container.resolve as jest.Mock).mockImplementation((name: string) => {
+      if (name === 'searchService') return service
+      if (name === 'searchIndexer') return lookup
+      throw new Error(`unexpected ${name}`)
+    })
+    await expect(
+      tool.handler({ entityId: 'customers:customer_person_profile', recordId: 'rec-1' }, ctx as any),
+    ).rejects.toThrow(/Insufficient permissions/)
+  })
+
+  it('allows an authorized caller to retrieve record context', async () => {
+    const lookup = makeLookup([
+      { entityId: 'customers:customer_person_profile', aclFeatures: ['customers.people.view'], enabled: true },
+    ])
+    const { service } = makeSearchService([
+      { entityId: 'customers:customer_person_profile', recordId: 'rec-1', score: 1, source: 'fulltext', presenter: { title: 'Person' }, url: '/backend/customers/people/rec-1', links: [] },
+    ])
+    const ctx = makeCtx({ userFeatures: ['search.view', 'customers.people.view'] })
+    ;(ctx.container.resolve as jest.Mock).mockImplementation((name: string) => {
+      if (name === 'searchService') return service
+      if (name === 'searchIndexer') return lookup
+      throw new Error(`unexpected ${name}`)
+    })
+    const result = (await tool.handler({ entityId: 'customers:customer_person_profile', recordId: 'rec-1' }, ctx as any)) as Record<string, unknown>
+    expect(result.found).toBe(true)
+    expect((result as any).presenter.title).toBe('Person')
+  })
+
+  it('filters stray results a strategy returned for an unreadable entity (defense in depth)', async () => {
+    const lookup = makeLookup([
+      { entityId: 'customers:customer_person_profile', aclFeatures: ['customers.people.view'], enabled: true },
+      { entityId: 'secret:thing', aclFeatures: ['secret.view'], enabled: true },
+    ])
+    // User can read person, but strategy returns secret thing for same recordId
+    const { service } = makeSearchService([
+      { entityId: 'secret:thing', recordId: 'rec-1', score: 1, source: 'fulltext', presenter: { title: 'Secret' } },
+    ])
+    const ctx = makeCtx({ userFeatures: ['search.view', 'customers.people.view'] })
+    ;(ctx.container.resolve as jest.Mock).mockImplementation((name: string) => {
+      if (name === 'searchService') return service
+      if (name === 'searchIndexer') return lookup
+      throw new Error(`unexpected ${name}`)
+    })
+    // Requesting person, but backend returned secret – should be filtered to not found
+    const result = (await tool.handler({ entityId: 'customers:customer_person_profile', recordId: 'rec-1' }, ctx as any)) as Record<string, unknown>
+    expect(result.found).toBe(false)
+  })
+
+  it('allows a superadmin to retrieve any record context', async () => {
+    const lookup = makeLookup([
+      { entityId: 'secret:thing', aclFeatures: ['secret.view'], enabled: true },
+    ])
+    const { service } = makeSearchService([
+      { entityId: 'secret:thing', recordId: 'rec-1', score: 1, source: 'fulltext', presenter: { title: 'Secret' }, url: '/x', links: [] },
+    ])
+    const ctx = makeCtx({ userFeatures: [], isSuperAdmin: true })
+    ;(ctx.container.resolve as jest.Mock).mockImplementation((name: string) => {
+      if (name === 'searchService') return service
+      if (name === 'searchIndexer') return lookup
+      throw new Error(`unexpected ${name}`)
+    })
+    const result = (await tool.handler({ entityId: 'secret:thing', recordId: 'rec-1' }, ctx as any)) as Record<string, unknown>
+    expect(result.found).toBe(true)
+  })
 })
 
 describe('search-pack tool surface', () => {

package/src/modules/ai_assistant/ai-tools/search-pack.ts

@@ -7,13 +7,68 @@
  */
 import { z } from 'zod'
 import type { SearchOptions, SearchResult, SearchStrategyId } from '@open-mercato/shared/modules/search'
+import {
+  canReadSearchEntity,
+  filterSearchResultsByEntityAccess,
+  resolveReadableEntityTypes,
+  type SearchEntityAccessSubject,
+  type SearchEntityConfigLookup,
+  type SearchEntityDenyReason,
+} from '@open-mercato/shared/lib/search/entityAccess'
 import { defineAiTool } from '../lib/ai-tool-definition'
-import type { AiToolDefinition } from '../lib/types'
+import type { AiToolDefinition, McpToolContext } from '../lib/types'
 
 type SearchServiceLike = {
   search: (query: string, options: SearchOptions) => Promise<SearchResult[]>
 }
 
+class SearchToolAuthorizationError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'SearchToolAuthorizationError'
+  }
+}
+
+function resolveSearchIndexer(ctx: McpToolContext): SearchEntityConfigLookup {
+  try {
+    const indexer = ctx.container.resolve('searchIndexer') as SearchEntityConfigLookup | undefined
+    if (indexer && typeof indexer.getEntityConfig === 'function' && typeof indexer.getAllEntityConfigs === 'function') {
+      return indexer
+    }
+  } catch {
+    // fall through to throw
+  }
+  throw new SearchToolAuthorizationError('[internal] Search entity registry unavailable')
+}
+
+function authorizeEntityAccess(
+  entityType: string,
+  lookup: SearchEntityConfigLookup,
+  subject: SearchEntityAccessSubject,
+): void {
+  if (subject.isSuperAdmin) return
+  let denial: SearchEntityDenyReason | undefined
+  const allowed = canReadSearchEntity(entityType, lookup, subject, {
+    onDeny: (_, reason) => {
+      denial = reason
+    },
+  })
+  if (allowed) return
+  if (denial === 'unconfigured') {
+    throw new SearchToolAuthorizationError(`[internal] Entity type "${entityType}" is not configured for search`)
+  }
+  if (denial === 'no-acl-features') {
+    throw new SearchToolAuthorizationError(
+      `[internal] Entity type "${entityType}" does not declare aclFeatures; access denied`,
+    )
+  }
+  const config = lookup.getEntityConfig(entityType)
+  const required = config?.aclFeatures ?? []
+  throw new SearchToolAuthorizationError(
+    `[internal] Insufficient permissions for entity "${entityType}". Required: ${required.join(', ')}`,
+  )
+}
+
 const hybridSearchInput = z.object({
   q: z.string().min(1).describe('Search query text.'),
   limit: z
@@ -49,13 +104,52 @@ const hybridSearchTool = defineAiTool({
     const service = ctx.container.resolve<SearchServiceLike>('searchService')
     const limit = input.limit ?? 20
     const started = Date.now()
-    const results = await service.search(input.q, {
+    const subject: SearchEntityAccessSubject = {
+      grantedFeatures: ctx.userFeatures,
+      isSuperAdmin: ctx.isSuperAdmin,
+    }
+
+    if (ctx.isSuperAdmin) {
+      const results = await service.search(input.q, {
+        tenantId: ctx.tenantId,
+        organizationId: ctx.organizationId,
+        limit,
+        strategies: input.strategies as SearchStrategyId[] | undefined,
+        entityTypes: input.entityTypes,
+      })
+      const timingMs = Date.now() - started
+      const strategiesUsed = Array.from(
+        new Set(results.map((result) => result.source).filter((id): id is SearchStrategyId => typeof id === 'string')),
+      )
+      return {
+        query: input.q,
+        totalResults: results.length,
+        results,
+        strategiesUsed,
+        timing: { ms: timingMs },
+      }
+    }
+
+    const lookup = resolveSearchIndexer(ctx)
+    const readableEntityTypes = resolveReadableEntityTypes(lookup, subject, input.entityTypes)
+    if (readableEntityTypes && readableEntityTypes.length === 0) {
+      return {
+        query: input.q,
+        totalResults: 0,
+        results: [],
+        strategiesUsed: [],
+        timing: { ms: Date.now() - started },
+      }
+    }
+
+    const rawResults = await service.search(input.q, {
       tenantId: ctx.tenantId,
       organizationId: ctx.organizationId,
       limit,
       strategies: input.strategies as SearchStrategyId[] | undefined,
-      entityTypes: input.entityTypes,
+      entityTypes: readableEntityTypes,
     })
+    const results = filterSearchResultsByEntityAccess(rawResults, lookup, subject)
     const timingMs = Date.now() - started
     const strategiesUsed = Array.from(
       new Set(results.map((result) => result.source).filter((id): id is SearchStrategyId => typeof id === 'string')),
@@ -88,13 +182,25 @@ const getRecordContextTool = defineAiTool({
       throw new Error('Tenant context is required for search.get_record_context')
     }
     const input = getRecordContextInput.parse(rawInput)
+    const subject: SearchEntityAccessSubject = {
+      grantedFeatures: ctx.userFeatures,
+      isSuperAdmin: ctx.isSuperAdmin,
+    }
+
+    let lookup: SearchEntityConfigLookup | undefined
+    if (!ctx.isSuperAdmin) {
+      lookup = resolveSearchIndexer(ctx)
+      authorizeEntityAccess(input.entityId, lookup, subject)
+    }
+
     const service = ctx.container.resolve<SearchServiceLike>('searchService')
-    const results = await service.search(input.recordId, {
+    const rawResults = await service.search(input.recordId, {
       tenantId: ctx.tenantId,
       organizationId: ctx.organizationId,
       limit: 5,
       entityTypes: [input.entityId],
     })
+    const results = lookup ? filterSearchResultsByEntityAccess(rawResults, lookup, subject) : rawResults
     const match = results.find((result) => result.recordId === input.recordId)
     if (!match) {
       return {

package/src/modules/ai_assistant/backend/config/ai-assistant/moderation-flags/AiModerationFlagsPageClient.tsx

@@ -32,6 +32,7 @@ type ModerationFlagsResponse = {
   total: number
   page: number
   pageSize: number
+  totalIsCapped?: boolean
 }
 
 async function fetchModerationFlags(params: {
@@ -123,6 +124,7 @@ export function AiModerationFlagsPageClient() {
   )
 
   const total = query.data?.total ?? 0
+  const totalIsCapped = query.data?.totalIsCapped === true
 
   return (
     <div className="flex flex-col gap-4">
@@ -176,6 +178,7 @@ export function AiModerationFlagsPageClient() {
           pageSize: PAGE_SIZE,
           total,
           totalPages: Math.max(1, Math.ceil(total / PAGE_SIZE)),
+          totalIsCapped,
           onPageChange: setPage,
         }}
       />

package/src/modules/ai_assistant/lib/__tests__/codemode-tool-annotations.test.ts

@@ -0,0 +1,58 @@
+import { loadCodeModeTools } from '../codemode-tools'
+import { buildMcpToolAnnotations } from '../mcp-tool-annotations'
+import { registerMcpTool } from '../tool-registry'
+import type { McpToolDefinition } from '../types'
+
+jest.mock('../api-endpoint-index', () => ({
+  getApiEndpoints: jest.fn(async () => []),
+  getRawOpenApiSpec: jest.fn(async () => null),
+}))
+
+jest.mock('../tool-registry', () => ({
+  registerMcpTool: jest.fn(),
+}))
+
+const mockedRegisterMcpTool = jest.mocked(registerMcpTool)
+
+async function loadRegisteredCodeModeTools(): Promise<Map<string, McpToolDefinition>> {
+  await loadCodeModeTools()
+  const tools = new Map<string, McpToolDefinition>()
+  for (const call of mockedRegisterMcpTool.mock.calls) {
+    const tool = call[0] as McpToolDefinition
+    tools.set(tool.name, tool)
+  }
+  return tools
+}
+
+describe('issue #5283 — Code Mode tools declare their mutation surface', () => {
+  beforeEach(() => {
+    mockedRegisterMcpTool.mockClear()
+  })
+
+  it('advertises the spec-querying search tool as read-only', async () => {
+    const tools = await loadRegisteredCodeModeTools()
+    const search = tools.get('search')
+
+    expect(search).toBeDefined()
+    expect(buildMcpToolAnnotations(search!)).toEqual({ readOnlyHint: true })
+  })
+
+  it('never advertises the api.request() execute tool as read-only', async () => {
+    const tools = await loadRegisteredCodeModeTools()
+    const execute = tools.get('execute')
+
+    expect(execute).toBeDefined()
+    expect(buildMcpToolAnnotations(execute!)).toEqual({
+      readOnlyHint: false,
+      destructiveHint: true,
+    })
+  })
+
+  it('registers both Code Mode tools under the codemode module id', async () => {
+    await loadRegisteredCodeModeTools()
+
+    for (const call of mockedRegisterMcpTool.mock.calls) {
+      expect(call[1]).toEqual({ moduleId: 'codemode' })
+    }
+  })
+})

package/src/modules/ai_assistant/lib/__tests__/generated-registry-loader.test.ts

@@ -36,6 +36,22 @@ function safeJsLiteral(value: string): string {
   return escapeUnsafeJsStringChars(JSON.stringify(value))
 }
 
+describe('Next.js bundle boundary', () => {
+  it('keeps runtime-only imports out of the Next.js bundle', () => {
+    const loaderSource = fs.readFileSync(
+      path.join(__dirname, '..', 'generated-registry-loader.ts'),
+      'utf8',
+    )
+
+    expect(loaderSource).toMatch(
+      /await import\(\s*\/\* webpackIgnore: true \*\/\s*\/\* turbopackIgnore: true \*\/\s*pathToFileURL\(jsPath\)\.href\s*\)/,
+    )
+    expect(loaderSource).toMatch(
+      /await import\(\s*\/\* webpackIgnore: true \*\/\s*\/\* turbopackIgnore: true \*\/\s*'@open-mercato\/shared\/lib\/bootstrap\/dynamicLoader'\s*\)/,
+    )
+  })
+})
+
 describe('rewriteGeneratedAliasImports', () => {
   // Regression for the MCP dev-server crash:
   //   "Cannot find package '@/.mercato' imported from .../tool-loader.js"

package/src/modules/ai_assistant/lib/__tests__/mcp-client.test.ts

@@ -90,4 +90,34 @@ describe('McpClient stdio transport', () => {
     expect(transportArgs.args).not.toContain('omk_secret.value')
     expect(JSON.stringify(transportArgs.args)).not.toContain('omk_secret.value')
   })
+
+  it('preserves all MCP tool annotations returned by a remote server', async () => {
+    mockClientListTools.mockResolvedValueOnce({
+      tools: [{
+        name: 'customers.update_company',
+        description: 'Update a company.',
+        inputSchema: {},
+        annotations: {
+          title: 'Update company',
+          readOnlyHint: false,
+          destructiveHint: false,
+          idempotentHint: true,
+          openWorldHint: false,
+        },
+      }],
+    })
+    const client = await McpClient.connect({ transport: 'stdio', apiKeySecret: 'test-secret' })
+
+    await expect(client.listTools()).resolves.toEqual([
+      expect.objectContaining({
+        annotations: {
+          title: 'Update company',
+          readOnlyHint: false,
+          destructiveHint: false,
+          idempotentHint: true,
+          openWorldHint: false,
+        },
+      }),
+    ])
+  })
 })