@open-mercato/search 0.6.6-develop.6290.1.4bb5a8ba3f → 0.6.6-develop.6299.1.29224e2d86

package/src/modules/search/frontend/components/sections/VectorSearchSection.tsx

@@ -44,7 +44,9 @@ type EmbeddingSettings = {
   autoIndexingLocked: boolean
   lockReason: string | null
   embeddingConfig: EmbeddingProviderConfig | null
+  embeddingConfigSource?: 'tenant' | 'instance' | 'env'
   configuredProviders: EmbeddingProviderId[]
+  providerAvailability?: { providerId: EmbeddingProviderId; available: boolean; reason?: string; models?: number }[]
   indexedDimension: number | null
   reindexRequired: boolean
   documentCount: number | null
@@ -531,11 +533,24 @@ export function VectorSearchSection({
               {/* Embedding Provider Selection */}
               <div>
                 <h3 className="text-sm font-semibold mb-2">{t('search.settings.vector.providers', 'Embedding Provider')}</h3>
-                <p className="text-xs text-muted-foreground mb-3">{t('search.settings.vector.providersHint', 'Select a provider to generate embeddings. Only providers with configured API keys can be selected.')}</p>
+                <p className="text-xs text-muted-foreground mb-1">{t('search.settings.vector.providersHint', 'Select a provider to generate embeddings. Only reachable providers can be selected.')}</p>
+                {embeddingSettings?.embeddingConfigSource && embeddingSettings.embeddingConfigSource !== 'tenant' && (
+                  <p className="text-xs text-muted-foreground mb-3">
+                    {t('search.settings.vector.inheritingDefault', 'This tenant is inheriting the instance/environment default. Saving a provider creates an override for this tenant.')}
+                  </p>
+                )}
+                {embeddingSettings?.embeddingConfigSource === 'tenant' && (
+                  <p className="text-xs text-muted-foreground mb-3">
+                    {t('search.settings.vector.usingTenantConfig', 'This tenant is using its own embedding settings.')}
+                  </p>
+                )}
                 <div className="grid gap-3 sm:grid-cols-2 lg:grid-cols-3 items-start">
                   {providerOptions.map((providerId) => {
                     const info = EMBEDDING_PROVIDERS[providerId]
-                    const isConfigured = embeddingSettings?.configuredProviders?.includes(providerId)
+                    const availability = embeddingSettings?.providerAvailability?.find((entry) => entry.providerId === providerId)
+                    const isConfigured = availability
+                      ? availability.available
+                      : embeddingSettings?.configuredProviders?.includes(providerId)
                     const isSelected = displayProvider === providerId
                     const isCurrentlySaved = savedProvider === providerId
                     return (
@@ -568,6 +583,10 @@ export function VectorSearchSection({
                               <p className="text-xs text-muted-foreground mt-1">
                                 {info.models.length} {t('search.settings.vector.modelsAvailable', 'models available')}
                               </p>
+                            ) : availability?.reason ? (
+                              <p className="text-xs text-status-warning-text mt-1">
+                                {availability.reason}
+                              </p>
                             ) : (
                               <p className="text-xs text-muted-foreground mt-1">
                                 {t('search.settings.vector.setEnvVar', 'Set')} <code className="font-mono text-overline bg-muted px-1 rounded">{info.envKeyRequired}</code>

package/src/modules/search/i18n/de.json

@@ -12,6 +12,7 @@
   "search.api.errors.missingQuery": "Suchanfrage ist erforderlich.",
   "search.api.errors.noIndexableStrategy": "Keine indizierbare Strategie verfügbar.",
   "search.api.errors.providerNotConfigured": "Anbieter ist nicht konfiguriert. Setzen Sie die erforderliche Umgebungsvariable.",
+  "search.api.errors.providerUnavailable": "Der ausgewählte Anbieter ist nicht verfügbar.",
   "search.api.errors.purgeFailed": "Suchindex konnte nicht bereinigt werden.",
   "search.api.errors.recreateFailed": "Fehler beim Neuerstellen der Vektortabelle mit neuer Dimension.",
   "search.api.errors.reindexFailed": "Neuindizierung fehlgeschlagen.",
@@ -156,6 +157,7 @@
   "search.settings.vector.comingSoon": "Demnächst verfügbar",
   "search.settings.vector.howTo": "Konfigurationsanleitung",
   "search.settings.vector.howToDescription": "Embedding-Anbieter für die Vektorsuche konfigurieren.",
+  "search.settings.vector.inheritingDefault": "Dieser Mandant erbt die Instanz-/Umgebungsvorgabe. Das Speichern eines Anbieters erstellt eine Überschreibung für diesen Mandanten.",
   "search.settings.vector.modelsAvailable": "Verfügbare Modelle",
   "search.settings.vector.providers": "Anbieter",
   "search.settings.vector.providersHint": "Embedding-Anbieter über Umgebungsvariablen konfigurieren.",
@@ -163,6 +165,7 @@
   "search.settings.vector.sectionTitle": "Vektorsuche",
   "search.settings.vector.setEnvVar": "Umgebungsvariable setzen",
   "search.settings.vector.store": "Vektorspeicher",
+  "search.settings.vector.usingTenantConfig": "Dieser Mandant verwendet eigene Embedding-Einstellungen.",
   "search.settings.vectorDocumentsLabel": "Vektordokumente",
   "search.settings.vectorNotConfigured": "Vektorsuche ist nicht konfiguriert.",
   "search.settings.vectorNotConfiguredHint": "Embedding-Anbieter-API-Schlüssel für die Vektorsuche setzen.",

package/src/modules/search/i18n/en.json

@@ -12,6 +12,7 @@
   "search.api.errors.missingQuery": "Search query is required.",
   "search.api.errors.noIndexableStrategy": "No indexable strategy is available.",
   "search.api.errors.providerNotConfigured": "Provider is not configured. Set the required environment variable.",
+  "search.api.errors.providerUnavailable": "The selected provider is not available.",
   "search.api.errors.purgeFailed": "Failed to purge search index.",
   "search.api.errors.recreateFailed": "Failed to recreate vector table with new dimension.",
   "search.api.errors.reindexFailed": "Reindex operation failed.",
@@ -156,6 +157,7 @@
   "search.settings.vector.comingSoon": "Coming soon",
   "search.settings.vector.howTo": "How to configure",
   "search.settings.vector.howToDescription": "Set up an embedding provider to enable vector search.",
+  "search.settings.vector.inheritingDefault": "This tenant is inheriting the instance/environment default. Saving a provider creates an override for this tenant.",
   "search.settings.vector.modelsAvailable": "Models available",
   "search.settings.vector.providers": "Providers",
   "search.settings.vector.providersHint": "Configure an embedding provider via environment variables.",
@@ -163,6 +165,7 @@
   "search.settings.vector.sectionTitle": "Vector Search",
   "search.settings.vector.setEnvVar": "Set environment variable",
   "search.settings.vector.store": "Vector store",
+  "search.settings.vector.usingTenantConfig": "This tenant is using its own embedding settings.",
   "search.settings.vectorDocumentsLabel": "Vector documents",
   "search.settings.vectorNotConfigured": "Vector search is not configured.",
   "search.settings.vectorNotConfiguredHint": "Set an embedding provider API key to enable vector search.",

package/src/modules/search/i18n/es.json

@@ -12,6 +12,7 @@
   "search.api.errors.missingQuery": "Se requiere una consulta de búsqueda.",
   "search.api.errors.noIndexableStrategy": "No hay estrategia indexable disponible.",
   "search.api.errors.providerNotConfigured": "El proveedor no está configurado. Configure la variable de entorno requerida.",
+  "search.api.errors.providerUnavailable": "El proveedor seleccionado no está disponible.",
   "search.api.errors.purgeFailed": "Error al purgar el índice de búsqueda.",
   "search.api.errors.recreateFailed": "No se pudo recrear la tabla vectorial con la nueva dimensión.",
   "search.api.errors.reindexFailed": "La operación de reindexación falló.",
@@ -156,6 +157,7 @@
   "search.settings.vector.comingSoon": "Próximamente",
   "search.settings.vector.howTo": "Cómo configurar",
   "search.settings.vector.howToDescription": "Configure un proveedor de embeddings para habilitar la búsqueda vectorial.",
+  "search.settings.vector.inheritingDefault": "Este inquilino hereda el valor predeterminado de la instancia/entorno. Guardar un proveedor crea una anulación para este inquilino.",
   "search.settings.vector.modelsAvailable": "Modelos disponibles",
   "search.settings.vector.providers": "Proveedores",
   "search.settings.vector.providersHint": "Configure un proveedor de embeddings mediante variables de entorno.",
@@ -163,6 +165,7 @@
   "search.settings.vector.sectionTitle": "Búsqueda vectorial",
   "search.settings.vector.setEnvVar": "Configurar variable de entorno",
   "search.settings.vector.store": "Almacén vectorial",
+  "search.settings.vector.usingTenantConfig": "Este inquilino usa su propia configuración de incrustaciones.",
   "search.settings.vectorDocumentsLabel": "Documentos vectoriales",
   "search.settings.vectorNotConfigured": "La búsqueda vectorial no está configurada.",
   "search.settings.vectorNotConfiguredHint": "Configure una clave API del proveedor de embeddings para la búsqueda vectorial.",

package/src/modules/search/i18n/pl.json

@@ -12,6 +12,7 @@
   "search.api.errors.missingQuery": "Zapytanie wyszukiwania jest wymagane.",
   "search.api.errors.noIndexableStrategy": "Brak dostępnej strategii indeksowania.",
   "search.api.errors.providerNotConfigured": "Dostawca nie jest skonfigurowany. Ustaw wymaganą zmienną środowiskową.",
+  "search.api.errors.providerUnavailable": "Wybrany dostawca jest niedostępny.",
   "search.api.errors.purgeFailed": "Nie udało się wyczyścić indeksu wyszukiwania.",
   "search.api.errors.recreateFailed": "Nie udało się odtworzyć tabeli wektorowej z nowym wymiarem.",
   "search.api.errors.reindexFailed": "Operacja reindeksacji nie powiodła się.",
@@ -156,6 +157,7 @@
   "search.settings.vector.comingSoon": "Wkrótce",
   "search.settings.vector.howTo": "Jak skonfigurować",
   "search.settings.vector.howToDescription": "Skonfiguruj dostawcę embeddingów, aby włączyć wyszukiwanie wektorowe.",
+  "search.settings.vector.inheritingDefault": "Ten najemca dziedziczy domyślne ustawienia instancji/środowiska. Zapisanie dostawcy tworzy nadpisanie dla tego najemcy.",
   "search.settings.vector.modelsAvailable": "Dostępne modele",
   "search.settings.vector.providers": "Dostawcy",
   "search.settings.vector.providersHint": "Skonfiguruj dostawcę embeddingów za pomocą zmiennych środowiskowych.",
@@ -163,6 +165,7 @@
   "search.settings.vector.sectionTitle": "Wyszukiwanie wektorowe",
   "search.settings.vector.setEnvVar": "Ustaw zmienną środowiskową",
   "search.settings.vector.store": "Magazyn wektorów",
+  "search.settings.vector.usingTenantConfig": "Ten najemca używa własnych ustawień osadzania.",
   "search.settings.vectorDocumentsLabel": "Dokumenty wektorowe",
   "search.settings.vectorNotConfigured": "Wyszukiwanie wektorowe nie jest skonfigurowane.",
   "search.settings.vectorNotConfiguredHint": "Ustaw klucz API dostawcy embeddingów, aby włączyć wyszukiwanie wektorowe.",

package/src/modules/search/lib/__tests__/provider-probe.test.ts

@@ -0,0 +1,137 @@
+import type { AppContainer } from '@open-mercato/shared/lib/di/container'
+import {
+  createEmbeddingProviderProbe,
+  probeOllama,
+  checkAllProviders,
+} from '../provider-probe'
+
+function createContainerWithCache() {
+  const store = new Map<string, unknown>()
+  let sets = 0
+  const cache = {
+    get: async (key: string) => store.get(key) ?? null,
+    set: async (key: string, value: unknown) => {
+      sets += 1
+      store.set(key, value)
+    },
+    delete: async () => {},
+    deleteByTags: async () => {},
+  }
+  const container = {
+    resolve: (token: string) => {
+      if (token === 'cache') return cache
+      throw new Error(`unknown token ${token}`)
+    },
+  } as unknown as AppContainer
+  return { container, sets: () => sets }
+}
+
+function mockFetch(impl: (input: string) => Promise<Response>) {
+  return jest.spyOn(globalThis, 'fetch' as never).mockImplementation(impl as never)
+}
+
+const okTags = (models: number) =>
+  ({
+    ok: true,
+    status: 200,
+    json: async () => ({ models: Array.from({ length: models }, (_, index) => ({ name: `m${index}` })) }),
+  }) as unknown as Response
+
+describe('probeOllama', () => {
+  afterEach(() => jest.restoreAllMocks())
+
+  it('reports available with model count on a successful /api/tags', async () => {
+    const spy = mockFetch(async () => okTags(3))
+    const result = await probeOllama('http://localhost:11434')
+    expect(result.available).toBe(true)
+    expect(result.models).toBe(3)
+    expect(spy).toHaveBeenCalledWith('http://localhost:11434/api/tags', expect.objectContaining({ method: 'GET' }))
+  })
+
+  it('reports unavailable on a non-ok response', async () => {
+    mockFetch(async () => ({ ok: false, status: 500 }) as unknown as Response)
+    const result = await probeOllama('http://localhost:11434')
+    expect(result.available).toBe(false)
+    expect(result.reason).toContain('500')
+  })
+
+  it('reports unavailable (timed out) when the request aborts', async () => {
+    mockFetch(async () => {
+      throw Object.assign(new Error('aborted'), { name: 'AbortError' })
+    })
+    const result = await probeOllama('http://localhost:11434')
+    expect(result.available).toBe(false)
+    expect(result.reason).toContain('timed out')
+  })
+
+  it('reports unavailable when the host is unreachable', async () => {
+    mockFetch(async () => {
+      throw new Error('ECONNREFUSED')
+    })
+    const result = await probeOllama('http://localhost:11434')
+    expect(result.available).toBe(false)
+    expect(result.reason).toContain('not reachable')
+  })
+})
+
+describe('createEmbeddingProviderProbe', () => {
+  afterEach(() => jest.restoreAllMocks())
+
+  it('caches results across calls and only probes once', async () => {
+    const spy = mockFetch(async () => okTags(1))
+    const { container, sets } = createContainerWithCache()
+    const probe = createEmbeddingProviderProbe(container)
+
+    const first = await probe.checkAvailability('ollama')
+    const second = await probe.checkAvailability('ollama')
+
+    expect(first.available).toBe(true)
+    expect(second.available).toBe(true)
+    expect(spy).toHaveBeenCalledTimes(1)
+    expect(sets()).toBe(1)
+  })
+
+  it('re-probes when force is set', async () => {
+    const spy = mockFetch(async () => okTags(1))
+    const { container } = createContainerWithCache()
+    const probe = createEmbeddingProviderProbe(container)
+
+    await probe.checkAvailability('ollama')
+    await probe.checkAvailability('ollama', { force: true })
+
+    expect(spy).toHaveBeenCalledTimes(2)
+  })
+
+  it('gates key-based providers on env-key presence', async () => {
+    const { container } = createContainerWithCache()
+    const probe = createEmbeddingProviderProbe(container)
+    const previous = process.env.OPENAI_API_KEY
+
+    try {
+      delete process.env.OPENAI_API_KEY
+      const missing = await probe.checkAvailability('openai')
+      expect(missing.available).toBe(false)
+      expect(missing.reason).toContain('OPENAI_API_KEY')
+
+      process.env.OPENAI_API_KEY = 'present'
+      const present = await probe.checkAvailability('openai', { force: true })
+      expect(present.available).toBe(true)
+    } finally {
+      if (previous === undefined) delete process.env.OPENAI_API_KEY
+      else process.env.OPENAI_API_KEY = previous
+    }
+  })
+})
+
+describe('checkAllProviders', () => {
+  it('returns an entry for every provider with its id', async () => {
+    const probe = {
+      checkAvailability: async () => ({ available: false, reason: 'stub' }),
+    }
+    const entries = await checkAllProviders(probe)
+    expect(entries.map((entry) => entry.providerId).sort()).toEqual(
+      ['bedrock', 'cohere', 'google', 'mistral', 'ollama', 'openai'],
+    )
+    expect(entries.every((entry) => entry.available === false)).toBe(true)
+  })
+})

package/src/modules/search/lib/__tests__/search-settings-scope.test.ts

@@ -0,0 +1,152 @@
+import { createModuleConfigService } from '@open-mercato/core/modules/configs/lib/module-config-service'
+import type { AppContainer } from '@open-mercato/shared/lib/di/container'
+import {
+  resolveEmbeddingConfigResult,
+  saveEmbeddingConfig,
+} from '../embedding-config'
+import {
+  resolveGlobalSearchStrategiesResult,
+  saveGlobalSearchStrategies,
+} from '../global-search-config'
+import type { EmbeddingProviderConfig } from '../../../../vector'
+
+type Row = {
+  id: string
+  moduleId: string
+  name: string
+  valueJson: unknown
+  tenantId: string | null
+  organizationId: string | null
+  createdAt: Date
+  updatedAt: Date
+}
+
+function matches(row: Row, where: Record<string, unknown>): boolean {
+  return Object.entries(where).every(([key, value]) => {
+    const current = (row as Record<string, unknown>)[key]
+    return value === null ? current === null || current === undefined : current === value
+  })
+}
+
+function createServiceResolver() {
+  const rows: Row[] = []
+  let seq = 0
+  const store = new Map<string, unknown>()
+  const repo = {
+    async findOne(where: Record<string, unknown>): Promise<Row | null> {
+      return rows.find((row) => matches(row, where)) ?? null
+    },
+    create(data: Partial<Row>): Row {
+      const now = new Date()
+      return {
+        id: `row-${seq++}`,
+        moduleId: data.moduleId!,
+        name: data.name!,
+        valueJson: data.valueJson ?? null,
+        tenantId: data.tenantId ?? null,
+        organizationId: data.organizationId ?? null,
+        createdAt: data.createdAt ?? now,
+        updatedAt: data.updatedAt ?? now,
+      }
+    },
+  }
+  const em = {
+    getRepository: () => repo,
+    persist: (entity: Row) => rows.push(entity),
+    flush: async () => {},
+  }
+  const cache = {
+    get: async (key: string) => store.get(key) ?? null,
+    set: async (key: string, value: unknown) => {
+      store.set(key, value)
+    },
+    delete: async (key: string) => {
+      store.delete(key)
+    },
+    deleteByTags: async () => {
+      store.clear()
+    },
+  }
+  const container = {
+    resolve: (token: string) => {
+      if (token === 'em') return em
+      if (token === 'cache') return cache
+      throw new Error(`unknown token ${token}`)
+    },
+  } as unknown as AppContainer
+  const service = createModuleConfigService(container)
+  const resolver = {
+    resolve: <T = unknown>(name: string): T => {
+      if (name === 'moduleConfigService') return service as unknown as T
+      throw new Error(`unknown token ${name}`)
+    },
+  }
+  return { resolver, rows }
+}
+
+const TENANT_A = '11111111-1111-1111-1111-111111111111'
+const TENANT_B = '22222222-2222-2222-2222-222222222222'
+
+const TENANT_A_CONFIG: EmbeddingProviderConfig = {
+  providerId: 'openai',
+  model: 'text-embedding-3-large',
+  dimension: 3072,
+  updatedAt: new Date().toISOString(),
+}
+
+describe('search settings tenant scoping (helper-level integration)', () => {
+  const previousKey = process.env.OPENAI_API_KEY
+  beforeAll(() => {
+    // Make the env-derived default deterministic across phases (key-presence gate).
+    process.env.OPENAI_API_KEY = 'test-key'
+  })
+  afterAll(() => {
+    if (previousKey === undefined) delete process.env.OPENAI_API_KEY
+    else process.env.OPENAI_API_KEY = previousKey
+  })
+
+  it('embedding config: Tenant A save does not change Tenant B (B inherits env default)', async () => {
+    const { resolver } = createServiceResolver()
+
+    await saveEmbeddingConfig(resolver, TENANT_A_CONFIG, { scope: { tenantId: TENANT_A } })
+
+    const a = await resolveEmbeddingConfigResult(resolver, { scope: { tenantId: TENANT_A } })
+    expect(a.source).toBe('tenant')
+    expect(a.config?.model).toBe('text-embedding-3-large')
+
+    const b = await resolveEmbeddingConfigResult(resolver, { scope: { tenantId: TENANT_B } })
+    expect(b.source).toBe('env')
+    expect(b.config?.providerId).toBe('openai')
+    expect(b.config?.model).toBe('text-embedding-3-small')
+  })
+
+  it('embedding config: a tenant inherits the instance row until it overrides', async () => {
+    const { resolver } = createServiceResolver()
+
+    // Instance default (no scope -> global row)
+    await saveEmbeddingConfig(resolver, { ...TENANT_A_CONFIG, model: 'instance-model' })
+
+    const inherited = await resolveEmbeddingConfigResult(resolver, { scope: { tenantId: TENANT_A } })
+    expect(inherited.source).toBe('instance')
+    expect(inherited.config?.model).toBe('instance-model')
+
+    await saveEmbeddingConfig(resolver, TENANT_A_CONFIG, { scope: { tenantId: TENANT_A } })
+    const overridden = await resolveEmbeddingConfigResult(resolver, { scope: { tenantId: TENANT_A } })
+    expect(overridden.source).toBe('tenant')
+    expect(overridden.config?.model).toBe('text-embedding-3-large')
+  })
+
+  it('global-search strategies: Tenant A save does not change Tenant B', async () => {
+    const { resolver } = createServiceResolver()
+
+    await saveGlobalSearchStrategies(resolver, ['fulltext'], { scope: { tenantId: TENANT_A } })
+
+    const a = await resolveGlobalSearchStrategiesResult(resolver, { scope: { tenantId: TENANT_A } })
+    expect(a.source).toBe('tenant')
+    expect(a.strategies).toEqual(['fulltext'])
+
+    const b = await resolveGlobalSearchStrategiesResult(resolver, { scope: { tenantId: TENANT_B } })
+    expect(b.source).toBe('env')
+    expect(b.strategies).toEqual(['fulltext', 'vector', 'tokens'])
+  })
+})

package/src/modules/search/lib/auto-indexing.ts

@@ -1,4 +1,4 @@
-import type { ModuleConfigService } from '@open-mercato/core/modules/configs/lib/module-config-service'
+import type { ConfigScope, ModuleConfigService } from '@open-mercato/core/modules/configs/lib/module-config-service'
 import { parseBooleanToken } from '@open-mercato/shared/lib/boolean'
 
 export const SEARCH_AUTO_INDEX_CONFIG_KEY = 'auto_index_enabled'
@@ -17,7 +17,7 @@ type Resolver = {
 
 export async function resolveAutoIndexingEnabled(
   resolver: Resolver,
-  options?: { defaultValue?: boolean },
+  options?: { defaultValue?: boolean; scope?: ConfigScope },
 ): Promise<boolean> {
   if (envDisablesAutoIndexing()) return false
   const fallback = options?.defaultValue ?? true
@@ -29,7 +29,10 @@ export async function resolveAutoIndexingEnabled(
   }
   try {
     // Still use 'vector' module key for backwards compatibility
-    const value = await service.getValue<boolean>('vector', SEARCH_AUTO_INDEX_CONFIG_KEY, { defaultValue: fallback })
+    const value = await service.getValue<boolean>('vector', SEARCH_AUTO_INDEX_CONFIG_KEY, {
+      defaultValue: fallback,
+      scope: options?.scope,
+    })
     return value !== false
   } catch {
     return fallback

package/src/modules/search/lib/embedding-config.ts

@@ -1,4 +1,4 @@
-import type { ModuleConfigService } from '@open-mercato/core/modules/configs/lib/module-config-service'
+import type { ConfigScope, ModuleConfigService } from '@open-mercato/core/modules/configs/lib/module-config-service'
 import type { EmbeddingProviderConfig, EmbeddingProviderId } from '../../../vector'
 import { EMBEDDING_CONFIG_KEY, EMBEDDING_PROVIDERS, DEFAULT_EMBEDDING_CONFIG } from '../../../vector'
 
@@ -123,7 +123,7 @@ type Resolver = {
 
 export async function resolveEmbeddingConfig(
   resolver: Resolver,
-  options?: { defaultValue?: EmbeddingProviderConfig | null }
+  options?: { defaultValue?: EmbeddingProviderConfig | null; scope?: ConfigScope }
 ): Promise<EmbeddingProviderConfig | null> {
   const fallback = options?.defaultValue ?? null
   let service: ModuleConfigService
@@ -133,7 +133,10 @@ export async function resolveEmbeddingConfig(
     return fallback
   }
   try {
-    const value = await service.getValue<EmbeddingProviderConfig>('vector', EMBEDDING_CONFIG_KEY, { defaultValue: fallback })
+    const value = await service.getValue<EmbeddingProviderConfig>('vector', EMBEDDING_CONFIG_KEY, {
+      defaultValue: fallback,
+      scope: options?.scope,
+    })
     return value
   } catch {
     return fallback
@@ -142,7 +145,8 @@ export async function resolveEmbeddingConfig(
 
 export async function saveEmbeddingConfig(
   resolver: Resolver,
-  config: EmbeddingProviderConfig
+  config: EmbeddingProviderConfig,
+  options?: { scope?: ConfigScope }
 ): Promise<void> {
   let service: ModuleConfigService
   try {
@@ -153,9 +157,58 @@ export async function saveEmbeddingConfig(
   await service.setValue('vector', EMBEDDING_CONFIG_KEY, {
     ...config,
     updatedAt: new Date().toISOString(),
-  })
+  }, options?.scope)
 }
 
 export function createDefaultConfig(): EmbeddingProviderConfig {
   return { ...DEFAULT_EMBEDDING_CONFIG, updatedAt: new Date().toISOString() }
 }
+
+export type EmbeddingConfigSource = 'tenant' | 'instance' | 'env'
+
+/**
+ * Compute the env-derived default embedding config: the platform default narrowed
+ * to the first env-configured provider. Returns null when no provider is configured.
+ */
+export function getEnvDerivedEmbeddingConfig(): EmbeddingProviderConfig | null {
+  const configured = getConfiguredProviders()
+  if (configured.length === 0) return null
+  const providerId = configured.includes(DEFAULT_EMBEDDING_CONFIG.providerId)
+    ? DEFAULT_EMBEDDING_CONFIG.providerId
+    : configured[0]
+  if (providerId === DEFAULT_EMBEDDING_CONFIG.providerId) {
+    return { ...DEFAULT_EMBEDDING_CONFIG, updatedAt: new Date().toISOString() }
+  }
+  const info = EMBEDDING_PROVIDERS[providerId]
+  const model = info.models.find((entry) => entry.id === info.defaultModel) ?? info.models[0]
+  return {
+    providerId,
+    model: info.defaultModel,
+    dimension: model?.dimension ?? DEFAULT_EMBEDDING_CONFIG.dimension,
+    updatedAt: new Date().toISOString(),
+  }
+}
+
+/**
+ * Resolve the embedding config together with its source discriminator:
+ * `tenant` (own scoped row), `instance` (inherited global row), or `env`
+ * (no stored row -> env-derived default).
+ */
+export async function resolveEmbeddingConfigResult(
+  resolver: Resolver,
+  options?: { scope?: ConfigScope },
+): Promise<{ config: EmbeddingProviderConfig | null; source: EmbeddingConfigSource }> {
+  let service: ModuleConfigService
+  try {
+    service = resolver.resolve<ModuleConfigService>('moduleConfigService')
+  } catch {
+    return { config: getEnvDerivedEmbeddingConfig(), source: 'env' }
+  }
+  try {
+    const record = await service.getRecord('vector', EMBEDDING_CONFIG_KEY, options?.scope)
+    if (record && record.value) {
+      return { config: record.value as EmbeddingProviderConfig, source: record.source }
+    }
+  } catch {}
+  return { config: getEnvDerivedEmbeddingConfig(), source: 'env' }
+}

package/src/modules/search/lib/global-search-config.ts

@@ -1,4 +1,4 @@
-import type { ModuleConfigService } from '@open-mercato/core/modules/configs/lib/module-config-service'
+import type { ConfigScope, ModuleConfigService } from '@open-mercato/core/modules/configs/lib/module-config-service'
 import type { SearchStrategyId } from '@open-mercato/shared/modules/search'
 
 export const GLOBAL_SEARCH_STRATEGIES_KEY = 'global_search_strategies'
@@ -16,7 +16,7 @@ type Resolver = {
  */
 export async function resolveGlobalSearchStrategies(
   resolver: Resolver,
-  options?: { defaultValue?: SearchStrategyId[] },
+  options?: { defaultValue?: SearchStrategyId[]; scope?: ConfigScope },
 ): Promise<SearchStrategyId[]> {
   const fallback = options?.defaultValue ?? DEFAULT_GLOBAL_SEARCH_STRATEGIES
   let service: ModuleConfigService
@@ -26,7 +26,10 @@ export async function resolveGlobalSearchStrategies(
     return fallback
   }
   try {
-    const value = await service.getValue<SearchStrategyId[]>('search', GLOBAL_SEARCH_STRATEGIES_KEY, { defaultValue: fallback })
+    const value = await service.getValue<SearchStrategyId[]>('search', GLOBAL_SEARCH_STRATEGIES_KEY, {
+      defaultValue: fallback,
+      scope: options?.scope,
+    })
     // Ensure we always return a non-empty array
     if (!Array.isArray(value) || value.length === 0) {
       return fallback
@@ -43,6 +46,7 @@ export async function resolveGlobalSearchStrategies(
 export async function saveGlobalSearchStrategies(
   resolver: Resolver,
   strategies: SearchStrategyId[],
+  options?: { scope?: ConfigScope },
 ): Promise<void> {
   let service: ModuleConfigService
   try {
@@ -65,5 +69,33 @@ export async function saveGlobalSearchStrategies(
     throw new Error('At least one valid search strategy must be enabled')
   }
 
-  await service.setValue('search', GLOBAL_SEARCH_STRATEGIES_KEY, validStrategies)
+  await service.setValue('search', GLOBAL_SEARCH_STRATEGIES_KEY, validStrategies, options?.scope)
+}
+
+export type GlobalSearchSource = 'tenant' | 'instance' | 'env'
+
+/**
+ * Resolve the enabled strategies together with their source discriminator:
+ * `tenant` (own scoped row), `instance` (inherited global row), or `env`
+ * (no stored row -> default strategies).
+ */
+export async function resolveGlobalSearchStrategiesResult(
+  resolver: Resolver,
+  options?: { defaultValue?: SearchStrategyId[]; scope?: ConfigScope },
+): Promise<{ strategies: SearchStrategyId[]; source: GlobalSearchSource }> {
+  const fallback = options?.defaultValue ?? DEFAULT_GLOBAL_SEARCH_STRATEGIES
+  let service: ModuleConfigService
+  try {
+    service = resolver.resolve<ModuleConfigService>('moduleConfigService')
+  } catch {
+    return { strategies: fallback, source: 'env' }
+  }
+  try {
+    const record = await service.getRecord('search', GLOBAL_SEARCH_STRATEGIES_KEY, options?.scope)
+    const value = record?.value
+    if (Array.isArray(value) && value.length > 0) {
+      return { strategies: value as SearchStrategyId[], source: record!.source }
+    }
+  } catch {}
+  return { strategies: fallback, source: 'env' }
 }