@open-mercato/search 0.6.6-develop.6296.1.5e8bdfee17 → 0.6.6-develop.6299.1.29224e2d86

package/dist/modules/search/lib/global-search-config.js

@@ -9,7 +9,10 @@ async function resolveGlobalSearchStrategies(resolver, options) {
     return fallback;
   }
   try {
-    const value = await service.getValue("search", GLOBAL_SEARCH_STRATEGIES_KEY, { defaultValue: fallback });
+    const value = await service.getValue("search", GLOBAL_SEARCH_STRATEGIES_KEY, {
+      defaultValue: fallback,
+      scope: options?.scope
+    });
     if (!Array.isArray(value) || value.length === 0) {
       return fallback;
     }
@@ -18,7 +21,7 @@ async function resolveGlobalSearchStrategies(resolver, options) {
     return fallback;
   }
 }
-async function saveGlobalSearchStrategies(resolver, strategies) {
+async function saveGlobalSearchStrategies(resolver, strategies, options) {
   let service;
   try {
     service = resolver.resolve("moduleConfigService");
@@ -34,12 +37,31 @@ async function saveGlobalSearchStrategies(resolver, strategies) {
   if (validStrategies.length === 0) {
     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);
+}
+async function resolveGlobalSearchStrategiesResult(resolver, options) {
+  const fallback = options?.defaultValue ?? DEFAULT_GLOBAL_SEARCH_STRATEGIES;
+  let service;
+  try {
+    service = resolver.resolve("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, source: record.source };
+    }
+  } catch {
+  }
+  return { strategies: fallback, source: "env" };
 }
 export {
   DEFAULT_GLOBAL_SEARCH_STRATEGIES,
   GLOBAL_SEARCH_STRATEGIES_KEY,
   resolveGlobalSearchStrategies,
+  resolveGlobalSearchStrategiesResult,
   saveGlobalSearchStrategies
 };
 //# sourceMappingURL=global-search-config.js.map

package/dist/modules/search/lib/global-search-config.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/modules/search/lib/global-search-config.ts"],
-  "sourcesContent": ["import type { ModuleConfigService } from '@open-mercato/core/modules/configs/lib/module-config-service'\nimport type { SearchStrategyId } from '@open-mercato/shared/modules/search'\n\nexport const GLOBAL_SEARCH_STRATEGIES_KEY = 'global_search_strategies'\n\n/** Default strategies when none are configured */\nexport const DEFAULT_GLOBAL_SEARCH_STRATEGIES: SearchStrategyId[] = ['fulltext', 'vector', 'tokens']\n\ntype Resolver = {\n  resolve: <T = unknown>(name: string) => T\n}\n\n/**\n * Get the enabled strategies for global search (Cmd+K).\n * Falls back to all strategies if not configured.\n */\nexport async function resolveGlobalSearchStrategies(\n  resolver: Resolver,\n  options?: { defaultValue?: SearchStrategyId[] },\n): Promise<SearchStrategyId[]> {\n  const fallback = options?.defaultValue ?? DEFAULT_GLOBAL_SEARCH_STRATEGIES\n  let service: ModuleConfigService\n  try {\n    service = resolver.resolve<ModuleConfigService>('moduleConfigService')\n  } catch {\n    return fallback\n  }\n  try {\n    const value = await service.getValue<SearchStrategyId[]>('search', GLOBAL_SEARCH_STRATEGIES_KEY, { defaultValue: fallback })\n    // Ensure we always return a non-empty array\n    if (!Array.isArray(value) || value.length === 0) {\n      return fallback\n    }\n    return value\n  } catch {\n    return fallback\n  }\n}\n\n/**\n * Save the enabled strategies for global search.\n */\nexport async function saveGlobalSearchStrategies(\n  resolver: Resolver,\n  strategies: SearchStrategyId[],\n): Promise<void> {\n  let service: ModuleConfigService\n  try {\n    service = resolver.resolve<ModuleConfigService>('moduleConfigService')\n  } catch {\n    throw new Error('Module config service not available')\n  }\n\n  // Validate that at least one strategy is enabled\n  if (!Array.isArray(strategies) || strategies.length === 0) {\n    throw new Error('At least one search strategy must be enabled')\n  }\n\n  // Filter to only valid strategy IDs\n  const validStrategies = strategies.filter(\n    (s) => ['fulltext', 'vector', 'tokens'].includes(s)\n  ) as SearchStrategyId[]\n\n  if (validStrategies.length === 0) {\n    throw new Error('At least one valid search strategy must be enabled')\n  }\n\n  await service.setValue('search', GLOBAL_SEARCH_STRATEGIES_KEY, validStrategies)\n}\n"],
-  "mappings": "AAGO,MAAM,+BAA+B;AAGrC,MAAM,mCAAuD,CAAC,YAAY,UAAU,QAAQ;AAUnG,eAAsB,8BACpB,UACA,SAC6B;AAC7B,QAAM,WAAW,SAAS,gBAAgB;AAC1C,MAAI;AACJ,MAAI;AACF,cAAU,SAAS,QAA6B,qBAAqB;AAAA,EACvE,QAAQ;AACN,WAAO;AAAA,EACT;AACA,MAAI;AACF,UAAM,QAAQ,MAAM,QAAQ,SAA6B,UAAU,8BAA8B,EAAE,cAAc,SAAS,CAAC;AAE3H,QAAI,CAAC,MAAM,QAAQ,KAAK,KAAK,MAAM,WAAW,GAAG;AAC/C,aAAO;AAAA,IACT;AACA,WAAO;AAAA,EACT,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAKA,eAAsB,2BACpB,UACA,YACe;AACf,MAAI;AACJ,MAAI;AACF,cAAU,SAAS,QAA6B,qBAAqB;AAAA,EACvE,QAAQ;AACN,UAAM,IAAI,MAAM,qCAAqC;AAAA,EACvD;AAGA,MAAI,CAAC,MAAM,QAAQ,UAAU,KAAK,WAAW,WAAW,GAAG;AACzD,UAAM,IAAI,MAAM,8CAA8C;AAAA,EAChE;AAGA,QAAM,kBAAkB,WAAW;AAAA,IACjC,CAAC,MAAM,CAAC,YAAY,UAAU,QAAQ,EAAE,SAAS,CAAC;AAAA,EACpD;AAEA,MAAI,gBAAgB,WAAW,GAAG;AAChC,UAAM,IAAI,MAAM,oDAAoD;AAAA,EACtE;AAEA,QAAM,QAAQ,SAAS,UAAU,8BAA8B,eAAe;AAChF;",
+  "sourcesContent": ["import type { ConfigScope, ModuleConfigService } from '@open-mercato/core/modules/configs/lib/module-config-service'\nimport type { SearchStrategyId } from '@open-mercato/shared/modules/search'\n\nexport const GLOBAL_SEARCH_STRATEGIES_KEY = 'global_search_strategies'\n\n/** Default strategies when none are configured */\nexport const DEFAULT_GLOBAL_SEARCH_STRATEGIES: SearchStrategyId[] = ['fulltext', 'vector', 'tokens']\n\ntype Resolver = {\n  resolve: <T = unknown>(name: string) => T\n}\n\n/**\n * Get the enabled strategies for global search (Cmd+K).\n * Falls back to all strategies if not configured.\n */\nexport async function resolveGlobalSearchStrategies(\n  resolver: Resolver,\n  options?: { defaultValue?: SearchStrategyId[]; scope?: ConfigScope },\n): Promise<SearchStrategyId[]> {\n  const fallback = options?.defaultValue ?? DEFAULT_GLOBAL_SEARCH_STRATEGIES\n  let service: ModuleConfigService\n  try {\n    service = resolver.resolve<ModuleConfigService>('moduleConfigService')\n  } catch {\n    return fallback\n  }\n  try {\n    const value = await service.getValue<SearchStrategyId[]>('search', GLOBAL_SEARCH_STRATEGIES_KEY, {\n      defaultValue: fallback,\n      scope: options?.scope,\n    })\n    // Ensure we always return a non-empty array\n    if (!Array.isArray(value) || value.length === 0) {\n      return fallback\n    }\n    return value\n  } catch {\n    return fallback\n  }\n}\n\n/**\n * Save the enabled strategies for global search.\n */\nexport async function saveGlobalSearchStrategies(\n  resolver: Resolver,\n  strategies: SearchStrategyId[],\n  options?: { scope?: ConfigScope },\n): Promise<void> {\n  let service: ModuleConfigService\n  try {\n    service = resolver.resolve<ModuleConfigService>('moduleConfigService')\n  } catch {\n    throw new Error('Module config service not available')\n  }\n\n  // Validate that at least one strategy is enabled\n  if (!Array.isArray(strategies) || strategies.length === 0) {\n    throw new Error('At least one search strategy must be enabled')\n  }\n\n  // Filter to only valid strategy IDs\n  const validStrategies = strategies.filter(\n    (s) => ['fulltext', 'vector', 'tokens'].includes(s)\n  ) as SearchStrategyId[]\n\n  if (validStrategies.length === 0) {\n    throw new Error('At least one valid search strategy must be enabled')\n  }\n\n  await service.setValue('search', GLOBAL_SEARCH_STRATEGIES_KEY, validStrategies, options?.scope)\n}\n\nexport type GlobalSearchSource = 'tenant' | 'instance' | 'env'\n\n/**\n * Resolve the enabled strategies together with their source discriminator:\n * `tenant` (own scoped row), `instance` (inherited global row), or `env`\n * (no stored row -> default strategies).\n */\nexport async function resolveGlobalSearchStrategiesResult(\n  resolver: Resolver,\n  options?: { defaultValue?: SearchStrategyId[]; scope?: ConfigScope },\n): Promise<{ strategies: SearchStrategyId[]; source: GlobalSearchSource }> {\n  const fallback = options?.defaultValue ?? DEFAULT_GLOBAL_SEARCH_STRATEGIES\n  let service: ModuleConfigService\n  try {\n    service = resolver.resolve<ModuleConfigService>('moduleConfigService')\n  } catch {\n    return { strategies: fallback, source: 'env' }\n  }\n  try {\n    const record = await service.getRecord('search', GLOBAL_SEARCH_STRATEGIES_KEY, options?.scope)\n    const value = record?.value\n    if (Array.isArray(value) && value.length > 0) {\n      return { strategies: value as SearchStrategyId[], source: record!.source }\n    }\n  } catch {}\n  return { strategies: fallback, source: 'env' }\n}\n"],
+  "mappings": "AAGO,MAAM,+BAA+B;AAGrC,MAAM,mCAAuD,CAAC,YAAY,UAAU,QAAQ;AAUnG,eAAsB,8BACpB,UACA,SAC6B;AAC7B,QAAM,WAAW,SAAS,gBAAgB;AAC1C,MAAI;AACJ,MAAI;AACF,cAAU,SAAS,QAA6B,qBAAqB;AAAA,EACvE,QAAQ;AACN,WAAO;AAAA,EACT;AACA,MAAI;AACF,UAAM,QAAQ,MAAM,QAAQ,SAA6B,UAAU,8BAA8B;AAAA,MAC/F,cAAc;AAAA,MACd,OAAO,SAAS;AAAA,IAClB,CAAC;AAED,QAAI,CAAC,MAAM,QAAQ,KAAK,KAAK,MAAM,WAAW,GAAG;AAC/C,aAAO;AAAA,IACT;AACA,WAAO;AAAA,EACT,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAKA,eAAsB,2BACpB,UACA,YACA,SACe;AACf,MAAI;AACJ,MAAI;AACF,cAAU,SAAS,QAA6B,qBAAqB;AAAA,EACvE,QAAQ;AACN,UAAM,IAAI,MAAM,qCAAqC;AAAA,EACvD;AAGA,MAAI,CAAC,MAAM,QAAQ,UAAU,KAAK,WAAW,WAAW,GAAG;AACzD,UAAM,IAAI,MAAM,8CAA8C;AAAA,EAChE;AAGA,QAAM,kBAAkB,WAAW;AAAA,IACjC,CAAC,MAAM,CAAC,YAAY,UAAU,QAAQ,EAAE,SAAS,CAAC;AAAA,EACpD;AAEA,MAAI,gBAAgB,WAAW,GAAG;AAChC,UAAM,IAAI,MAAM,oDAAoD;AAAA,EACtE;AAEA,QAAM,QAAQ,SAAS,UAAU,8BAA8B,iBAAiB,SAAS,KAAK;AAChG;AASA,eAAsB,oCACpB,UACA,SACyE;AACzE,QAAM,WAAW,SAAS,gBAAgB;AAC1C,MAAI;AACJ,MAAI;AACF,cAAU,SAAS,QAA6B,qBAAqB;AAAA,EACvE,QAAQ;AACN,WAAO,EAAE,YAAY,UAAU,QAAQ,MAAM;AAAA,EAC/C;AACA,MAAI;AACF,UAAM,SAAS,MAAM,QAAQ,UAAU,UAAU,8BAA8B,SAAS,KAAK;AAC7F,UAAM,QAAQ,QAAQ;AACtB,QAAI,MAAM,QAAQ,KAAK,KAAK,MAAM,SAAS,GAAG;AAC5C,aAAO,EAAE,YAAY,OAA6B,QAAQ,OAAQ,OAAO;AAAA,IAC3E;AAAA,EACF,QAAQ;AAAA,EAAC;AACT,SAAO,EAAE,YAAY,UAAU,QAAQ,MAAM;AAC/C;",
   "names": []
 }

package/dist/modules/search/lib/provider-probe.js

@@ -0,0 +1,108 @@
+import { EMBEDDING_PROVIDERS } from "../../../vector/index.js";
+const CACHE_VERSION = "v1";
+const CACHE_TTL_MS = 3e4;
+const OLLAMA_PROBE_TIMEOUT_MS = 1500;
+const ALL_PROVIDERS = ["openai", "google", "mistral", "cohere", "bedrock", "ollama"];
+async function checkAllProviders(probe, options) {
+  return Promise.all(
+    ALL_PROVIDERS.map(async (providerId) => ({
+      providerId,
+      ...await probe.checkAvailability(providerId, options)
+    }))
+  );
+}
+const cacheKey = (providerId) => `embedding-provider-probe:${CACHE_VERSION}:${providerId}`;
+const resolveCache = (container) => {
+  try {
+    return container.resolve("cache");
+  } catch {
+    return null;
+  }
+};
+const ollamaBaseUrl = () => process.env.OLLAMA_BASE_URL ?? "http://localhost:11434";
+const keyPresence = (providerId) => {
+  const info = EMBEDDING_PROVIDERS[providerId];
+  const envKey = info?.envKeyRequired;
+  switch (providerId) {
+    case "openai":
+      return process.env.OPENAI_API_KEY?.trim() ? { available: true } : { available: false, reason: `Set ${envKey} to enable ${info?.name ?? providerId}` };
+    case "google":
+      return process.env.GOOGLE_GENERATIVE_AI_API_KEY?.trim() ? { available: true } : { available: false, reason: `Set ${envKey} to enable ${info?.name ?? providerId}` };
+    case "mistral":
+      return process.env.MISTRAL_API_KEY?.trim() ? { available: true } : { available: false, reason: `Set ${envKey} to enable ${info?.name ?? providerId}` };
+    case "cohere":
+      return process.env.COHERE_API_KEY?.trim() ? { available: true } : { available: false, reason: `Set ${envKey} to enable ${info?.name ?? providerId}` };
+    case "bedrock":
+      return process.env.AWS_ACCESS_KEY_ID?.trim() && process.env.AWS_SECRET_ACCESS_KEY?.trim() ? { available: true } : { available: false, reason: "Set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY to enable Bedrock" };
+    default:
+      return { available: false, reason: `Unknown provider: ${providerId}` };
+  }
+};
+async function probeOllama(baseUrl) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), OLLAMA_PROBE_TIMEOUT_MS);
+  try {
+    const response = await fetch(`${baseUrl.replace(/\/$/, "")}/api/tags`, {
+      method: "GET",
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      return { available: false, reason: `Ollama responded ${response.status} at ${baseUrl}` };
+    }
+    let models;
+    try {
+      const payload = await response.json();
+      if (Array.isArray(payload?.models)) models = payload.models.length;
+    } catch {
+    }
+    return { available: true, models };
+  } catch (error) {
+    const aborted = error instanceof Error && error.name === "AbortError";
+    return {
+      available: false,
+      reason: aborted ? `Ollama not reachable at ${baseUrl} (timed out)` : `Ollama not reachable at ${baseUrl}`
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function computeAvailability(providerId) {
+  try {
+    if (providerId === "ollama") {
+      return await probeOllama(ollamaBaseUrl());
+    }
+    return keyPresence(providerId);
+  } catch (error) {
+    return { available: false, reason: error instanceof Error ? error.message : "Availability check failed" };
+  }
+}
+function createEmbeddingProviderProbe(container) {
+  const checkAvailability = async (providerId, options) => {
+    const cache = resolveCache(container);
+    const key = cacheKey(providerId);
+    if (!options?.force && cache) {
+      try {
+        const cached = await cache.get(key);
+        if (cached && typeof cached === "object" && "available" in cached) {
+          return cached;
+        }
+      } catch {
+      }
+    }
+    const result = await computeAvailability(providerId);
+    if (cache) {
+      try {
+        await cache.set(key, result, { ttl: CACHE_TTL_MS });
+      } catch {
+      }
+    }
+    return result;
+  };
+  return { checkAvailability };
+}
+export {
+  checkAllProviders,
+  createEmbeddingProviderProbe,
+  probeOllama
+};
+//# sourceMappingURL=provider-probe.js.map

package/dist/modules/search/lib/provider-probe.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/search/lib/provider-probe.ts"],
+  "sourcesContent": ["import type { CacheStrategy } from '@open-mercato/cache'\nimport type { AppContainer } from '@open-mercato/shared/lib/di/container'\nimport type { EmbeddingProviderId } from '../../../vector'\nimport { EMBEDDING_PROVIDERS } from '../../../vector'\n\nconst CACHE_VERSION = 'v1'\nconst CACHE_TTL_MS = 30_000\nconst OLLAMA_PROBE_TIMEOUT_MS = 1500\n\nexport type ProviderAvailability = {\n  available: boolean\n  reason?: string\n  models?: number\n}\n\nexport type ProviderAvailabilityEntry = ProviderAvailability & {\n  providerId: EmbeddingProviderId\n}\n\nexport type EmbeddingProviderProbe = {\n  checkAvailability(providerId: EmbeddingProviderId, options?: { force?: boolean }): Promise<ProviderAvailability>\n}\n\nconst ALL_PROVIDERS: EmbeddingProviderId[] = ['openai', 'google', 'mistral', 'cohere', 'bedrock', 'ollama']\n\nexport async function checkAllProviders(\n  probe: EmbeddingProviderProbe,\n  options?: { force?: boolean },\n): Promise<ProviderAvailabilityEntry[]> {\n  return Promise.all(\n    ALL_PROVIDERS.map(async (providerId) => ({\n      providerId,\n      ...(await probe.checkAvailability(providerId, options)),\n    })),\n  )\n}\n\nconst cacheKey = (providerId: string) => `embedding-provider-probe:${CACHE_VERSION}:${providerId}`\n\nconst resolveCache = (container: AppContainer): CacheStrategy | null => {\n  try {\n    return container.resolve('cache') as CacheStrategy\n  } catch {\n    return null\n  }\n}\n\nconst ollamaBaseUrl = () => process.env.OLLAMA_BASE_URL ?? 'http://localhost:11434'\n\nconst keyPresence = (providerId: EmbeddingProviderId): ProviderAvailability => {\n  const info = EMBEDDING_PROVIDERS[providerId]\n  const envKey = info?.envKeyRequired\n  switch (providerId) {\n    case 'openai':\n      return process.env.OPENAI_API_KEY?.trim()\n        ? { available: true }\n        : { available: false, reason: `Set ${envKey} to enable ${info?.name ?? providerId}` }\n    case 'google':\n      return process.env.GOOGLE_GENERATIVE_AI_API_KEY?.trim()\n        ? { available: true }\n        : { available: false, reason: `Set ${envKey} to enable ${info?.name ?? providerId}` }\n    case 'mistral':\n      return process.env.MISTRAL_API_KEY?.trim()\n        ? { available: true }\n        : { available: false, reason: `Set ${envKey} to enable ${info?.name ?? providerId}` }\n    case 'cohere':\n      return process.env.COHERE_API_KEY?.trim()\n        ? { available: true }\n        : { available: false, reason: `Set ${envKey} to enable ${info?.name ?? providerId}` }\n    case 'bedrock':\n      return process.env.AWS_ACCESS_KEY_ID?.trim() && process.env.AWS_SECRET_ACCESS_KEY?.trim()\n        ? { available: true }\n        : { available: false, reason: 'Set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY to enable Bedrock' }\n    default:\n      return { available: false, reason: `Unknown provider: ${providerId}` }\n  }\n}\n\nexport async function probeOllama(baseUrl: string): Promise<ProviderAvailability> {\n  const controller = new AbortController()\n  const timer = setTimeout(() => controller.abort(), OLLAMA_PROBE_TIMEOUT_MS)\n  try {\n    const response = await fetch(`${baseUrl.replace(/\\/$/, '')}/api/tags`, {\n      method: 'GET',\n      signal: controller.signal,\n    })\n    if (!response.ok) {\n      return { available: false, reason: `Ollama responded ${response.status} at ${baseUrl}` }\n    }\n    let models: number | undefined\n    try {\n      const payload = (await response.json()) as { models?: unknown[] }\n      if (Array.isArray(payload?.models)) models = payload.models.length\n    } catch {}\n    return { available: true, models }\n  } catch (error) {\n    const aborted = error instanceof Error && error.name === 'AbortError'\n    return {\n      available: false,\n      reason: aborted ? `Ollama not reachable at ${baseUrl} (timed out)` : `Ollama not reachable at ${baseUrl}`,\n    }\n  } finally {\n    clearTimeout(timer)\n  }\n}\n\nasync function computeAvailability(providerId: EmbeddingProviderId): Promise<ProviderAvailability> {\n  try {\n    if (providerId === 'ollama') {\n      return await probeOllama(ollamaBaseUrl())\n    }\n    return keyPresence(providerId)\n  } catch (error) {\n    // Fail closed: any unexpected error means the provider is treated as unavailable.\n    return { available: false, reason: error instanceof Error ? error.message : 'Availability check failed' }\n  }\n}\n\nexport function createEmbeddingProviderProbe(container: AppContainer): EmbeddingProviderProbe {\n  const checkAvailability = async (\n    providerId: EmbeddingProviderId,\n    options?: { force?: boolean },\n  ): Promise<ProviderAvailability> => {\n    const cache = resolveCache(container)\n    const key = cacheKey(providerId)\n    if (!options?.force && cache) {\n      try {\n        const cached = await cache.get(key)\n        if (cached && typeof cached === 'object' && 'available' in cached) {\n          return cached as ProviderAvailability\n        }\n      } catch {}\n    }\n    const result = await computeAvailability(providerId)\n    if (cache) {\n      try {\n        await cache.set(key, result, { ttl: CACHE_TTL_MS })\n      } catch {}\n    }\n    return result\n  }\n  return { checkAvailability }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-mercato/search",
-  "version": "0.6.6-develop.6296.1.5e8bdfee17",
+  "version": "0.6.6-develop.6299.1.29224e2d86",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",
@@ -127,9 +127,9 @@
     "zod": "^4.4.3"
   },
   "peerDependencies": {
-    "@open-mercato/core": "0.6.6-develop.6296.1.5e8bdfee17",
-    "@open-mercato/queue": "0.6.6-develop.6296.1.5e8bdfee17",
-    "@open-mercato/shared": "0.6.6-develop.6296.1.5e8bdfee17"
+    "@open-mercato/core": "0.6.6-develop.6299.1.29224e2d86",
+    "@open-mercato/queue": "0.6.6-develop.6299.1.29224e2d86",
+    "@open-mercato/shared": "0.6.6-develop.6299.1.29224e2d86"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",

package/src/modules/search/__integration__/TC-SEARCH-010.spec.ts

@@ -0,0 +1,74 @@
+import { expect, test } from '@playwright/test'
+import { apiRequest, getAuthToken } from '@open-mercato/core/helpers/integration/api'
+import { readJsonSafe } from '@open-mercato/core/helpers/integration/generalFixtures'
+
+type GlobalSearchSettings = {
+  enabledStrategies?: string[]
+  source?: 'tenant' | 'instance' | 'env'
+}
+type EmbeddingsSettings = {
+  settings?: {
+    embeddingConfig?: unknown
+    embeddingConfigSource?: 'tenant' | 'instance' | 'env'
+  }
+}
+
+const DEFAULT_STRATEGIES = ['fulltext', 'vector', 'tokens']
+
+/**
+ * TC-SEARCH-010: search settings carry a tenant-scope source discriminator.
+ * Source: .ai/specs/2026-06-15-tenant-scoped-search-settings.md (Phase 2).
+ *
+ * The settings APIs are tenant-scoped: GET reports a `source` of tenant | instance
+ * | env, and a tenant admin's POST writes only its own scoped row (subsequent GET
+ * reports `source: 'tenant'`). This spec is self-contained — it restores the
+ * tenant's original global-search strategies in `finally`.
+ */
+test.describe('TC-SEARCH-010: tenant-scoped search settings expose a source', () => {
+  test('global-search GET exposes source and POST round-trips as a tenant override', async ({ request }) => {
+    let token: string | null = null
+    let original: string[] | null = null
+
+    try {
+      token = await getAuthToken(request, 'admin')
+
+      const before = await apiRequest(request, 'GET', '/api/search/settings/global-search', { token })
+      expect(before.ok(), 'admin should read global-search settings').toBeTruthy()
+      const beforeBody = (await readJsonSafe<GlobalSearchSettings>(before)) ?? {}
+      expect(Array.isArray(beforeBody.enabledStrategies)).toBeTruthy()
+      original = beforeBody.enabledStrategies ?? DEFAULT_STRATEGIES
+      expect(['tenant', 'instance', 'env']).toContain(beforeBody.source)
+
+      const next = original.includes('vector')
+        ? original.filter((strategy) => strategy !== 'vector')
+        : [...original, 'vector']
+      const safeNext = next.length > 0 ? next : ['tokens']
+
+      const update = await apiRequest(request, 'POST', '/api/search/settings/global-search', {
+        token,
+        data: { enabledStrategies: safeNext },
+      })
+      expect(update.ok(), 'admin should update global-search settings').toBeTruthy()
+
+      const after = await apiRequest(request, 'GET', '/api/search/settings/global-search', { token })
+      const afterBody = (await readJsonSafe<GlobalSearchSettings>(after)) ?? {}
+      expect(afterBody.enabledStrategies?.sort()).toEqual([...safeNext].sort())
+      expect(afterBody.source, 'after a tenant save the source is the tenant row').toBe('tenant')
+    } finally {
+      if (token && original) {
+        await apiRequest(request, 'POST', '/api/search/settings/global-search', {
+          token,
+          data: { enabledStrategies: original },
+        }).catch(() => undefined)
+      }
+    }
+  })
+
+  test('embeddings GET exposes the embedding config source', async ({ request }) => {
+    const token = await getAuthToken(request, 'admin')
+    const response = await apiRequest(request, 'GET', '/api/search/embeddings', { token })
+    expect(response.ok(), 'admin should read embedding settings').toBeTruthy()
+    const body = (await readJsonSafe<EmbeddingsSettings>(response)) ?? {}
+    expect(['tenant', 'instance', 'env']).toContain(body.settings?.embeddingConfigSource)
+  })
+})

package/src/modules/search/__integration__/TC-SEARCH-011.spec.ts

@@ -0,0 +1,46 @@
+import { expect, test } from '@playwright/test'
+import { apiRequest, getAuthToken } from '@open-mercato/core/helpers/integration/api'
+import { readJsonSafe } from '@open-mercato/core/helpers/integration/generalFixtures'
+
+type ProviderAvailabilityEntry = { providerId: string; available: boolean; reason?: string }
+type EmbeddingsSettings = {
+  settings?: {
+    providerAvailability?: ProviderAvailabilityEntry[]
+  }
+}
+type SaveError = { error?: string; reason?: string }
+
+/**
+ * TC-SEARCH-011: the embeddings save guard rejects an unreachable provider.
+ * Source: .ai/specs/2026-06-15-tenant-scoped-search-settings.md (Phase 3/4).
+ *
+ * POST /api/search/embeddings must reject selecting a provider the availability
+ * probe reports unreachable with a 409 + structured reason, so a dead provider
+ * (e.g. Ollama with nothing listening) can never be persisted. This is read-only
+ * on the failure path (no state changes), so it is self-contained.
+ */
+test.describe('TC-SEARCH-011: save guard rejects an unavailable provider', () => {
+  test('selecting Ollama while it is unreachable is rejected with 409 + reason', async ({ request }) => {
+    const token = await getAuthToken(request, 'admin')
+
+    const settingsResp = await apiRequest(request, 'GET', '/api/search/embeddings', { token })
+    expect(settingsResp.ok(), 'admin should read embedding settings').toBeTruthy()
+    const settings = (await readJsonSafe<EmbeddingsSettings>(settingsResp)) ?? {}
+    const availability = settings.settings?.providerAvailability ?? []
+    expect(Array.isArray(availability)).toBeTruthy()
+
+    const ollama = availability.find((entry) => entry.providerId === 'ollama')
+    test.skip(!ollama, 'provider availability not exposed by this build')
+    test.skip(ollama?.available === true, 'Ollama is reachable in this environment; cannot exercise the rejection path')
+
+    const response = await apiRequest(request, 'POST', '/api/search/embeddings', {
+      token,
+      data: { embeddingConfig: { providerId: 'ollama', model: 'nomic-embed-text', dimension: 768 } },
+    })
+
+    expect(response.status(), 'an unavailable provider must be rejected').toBe(409)
+    const body = (await readJsonSafe<SaveError>(response)) ?? {}
+    expect(typeof body.error, 'the rejection carries an error message').toBe('string')
+    expect(body, 'the rejection exposes a structured reason').toHaveProperty('reason')
+  })
+})

package/src/modules/search/api/embeddings/__tests__/route.ollama-base-url.test.ts

@@ -15,12 +15,14 @@ jest.mock('@open-mercato/shared/lib/i18n/server', () => ({
 }))
 
 const mockResolveEmbeddingConfig = jest.fn()
+const mockResolveEmbeddingConfigResult = jest.fn()
 const mockSaveEmbeddingConfig = jest.fn()
 const mockGetConfiguredProviders = jest.fn()
 const mockDetectConfigChange = jest.fn()
 const mockGetEffectiveDimension = jest.fn()
 jest.mock('../../../lib/embedding-config', () => ({
   resolveEmbeddingConfig: (...args: unknown[]) => mockResolveEmbeddingConfig(...args),
+  resolveEmbeddingConfigResult: (...args: unknown[]) => mockResolveEmbeddingConfigResult(...args),
   saveEmbeddingConfig: (...args: unknown[]) => mockSaveEmbeddingConfig(...args),
   getConfiguredProviders: (...args: unknown[]) => mockGetConfiguredProviders(...args),
   detectConfigChange: (...args: unknown[]) => mockDetectConfigChange(...args),
@@ -71,6 +73,7 @@ describe('POST /api/search/embeddings — Ollama baseUrl SSRF guard', () => {
     })
 
     mockResolveEmbeddingConfig.mockResolvedValue(null)
+    mockResolveEmbeddingConfigResult.mockResolvedValue({ config: null, source: 'env' })
     mockGetConfiguredProviders.mockReturnValue(['ollama', 'openai'])
     mockGetEffectiveDimension.mockReturnValue(768)
     mockDetectConfigChange.mockImplementation((_existing: unknown, next: unknown) => ({

package/src/modules/search/api/embeddings/route.ts

@@ -6,11 +6,15 @@ import type { ModuleConfigService } from '@open-mercato/core/modules/configs/lib
 import { envDisablesAutoIndexing, resolveAutoIndexingEnabled, SEARCH_AUTO_INDEX_CONFIG_KEY } from '../../lib/auto-indexing'
 import {
   resolveEmbeddingConfig,
+  resolveEmbeddingConfigResult,
   saveEmbeddingConfig,
   getConfiguredProviders,
   detectConfigChange,
   getEffectiveDimension,
 } from '../../lib/embedding-config'
+import type { EmbeddingConfigSource } from '../../lib/embedding-config'
+import { checkAllProviders } from '../../lib/provider-probe'
+import type { EmbeddingProviderProbe, ProviderAvailabilityEntry } from '../../lib/provider-probe'
 import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
 import type { EmbeddingProviderConfig, EmbeddingProviderId, VectorDriver } from '../../../../vector'
 import { EMBEDDING_PROVIDERS, DEFAULT_EMBEDDING_CONFIG, EmbeddingService } from '../../../../vector'
@@ -46,7 +50,9 @@ type SettingsResponse = {
     autoIndexingLocked: boolean
     lockReason: string | null
     embeddingConfig: EmbeddingProviderConfig | null
+    embeddingConfigSource: EmbeddingConfigSource
     configuredProviders: EmbeddingProviderId[]
+    providerAvailability: ProviderAvailabilityEntry[]
     indexedDimension: number | null
     reindexRequired: boolean
     documentCount: number | null
@@ -67,6 +73,26 @@ const configUnavailable = async () => {
   return NextResponse.json({ error: t('search.api.errors.configUnavailable', 'Configuration service unavailable') }, { status: 503 })
 }
 
+function resolveProbe(container: { resolve: <T = unknown>(name: string) => T }): EmbeddingProviderProbe | null {
+  try {
+    return container.resolve<EmbeddingProviderProbe>('embeddingProviderProbe')
+  } catch {
+    return null
+  }
+}
+
+async function resolveProviderAvailability(
+  container: { resolve: <T = unknown>(name: string) => T },
+): Promise<ProviderAvailabilityEntry[]> {
+  const probe = resolveProbe(container)
+  if (!probe) return []
+  try {
+    return await checkAllProviders(probe)
+  } catch {
+    return []
+  }
+}
+
 async function getIndexedDimension(container: { resolve: <T = unknown>(name: string) => T }): Promise<number | null> {
   try {
     const drivers = container.resolve<VectorDriver[]>('vectorDrivers')
@@ -107,14 +133,17 @@ export async function GET(req: Request) {
     let autoIndexingEnabled = !lockedByEnv
     if (!lockedByEnv) {
       try {
-        autoIndexingEnabled = await resolveAutoIndexingEnabled(container, { defaultValue: true })
+        autoIndexingEnabled = await resolveAutoIndexingEnabled(container, { defaultValue: true, scope: { tenantId: auth.tenantId } })
       } catch {
         autoIndexingEnabled = true
       }
     }
 
-    const embeddingConfig = await resolveEmbeddingConfig(container, { defaultValue: null })
+    const { config: embeddingConfig, source: embeddingConfigSource } = await resolveEmbeddingConfigResult(container, {
+      scope: { tenantId: auth.tenantId },
+    })
     const configuredProviders = getConfiguredProviders()
+    const providerAvailability = await resolveProviderAvailability(container)
     const indexedDimension = await getIndexedDimension(container)
 
     const effectiveDimension = embeddingConfig
@@ -139,7 +168,9 @@ export async function GET(req: Request) {
         autoIndexingLocked: lockedByEnv,
         lockReason: lockedByEnv ? 'env' : null,
         embeddingConfig,
+        embeddingConfigSource,
         configuredProviders,
+        providerAvailability,
         indexedDimension,
         reindexRequired,
         documentCount,
@@ -190,10 +221,10 @@ export async function POST(req: Request) {
           { status: 409 },
         )
       }
-      await service.setValue('vector', SEARCH_AUTO_INDEX_CONFIG_KEY, parsed.data.autoIndexingEnabled)
+      await service.setValue('vector', SEARCH_AUTO_INDEX_CONFIG_KEY, parsed.data.autoIndexingEnabled, { tenantId: auth.tenantId })
     }
 
-    let embeddingConfig = await resolveEmbeddingConfig(container, { defaultValue: null })
+    let embeddingConfig = await resolveEmbeddingConfig(container, { defaultValue: null, scope: { tenantId: auth.tenantId } })
     let reindexRequired = false
     let indexedDimension = await getIndexedDimension(container)
 
@@ -216,6 +247,7 @@ export async function POST(req: Request) {
         )
       }
 
+      // Reject an unsafe user-supplied Ollama base URL before doing anything with it (SSRF guard).
       if (newConfig.providerId === 'ollama' && newConfig.baseUrl != null) {
         try {
           assertSafeOllamaBaseUrl(newConfig.baseUrl)
@@ -236,6 +268,24 @@ export async function POST(req: Request) {
         }
       }
 
+      // Save-time availability guard: never persist a provider the probe reports unreachable.
+      const probe = resolveProbe(container)
+      if (probe) {
+        const availability = await probe.checkAvailability(newConfig.providerId)
+        if (!availability.available) {
+          return NextResponse.json(
+            {
+              error: t(
+                'search.api.errors.providerUnavailable',
+                `Provider ${providerInfo.name} is not available: ${availability.reason ?? 'unreachable'}`,
+              ),
+              reason: availability.reason ?? null,
+            },
+            { status: 409 },
+          )
+        }
+      }
+
       const change = detectConfigChange(
         embeddingConfig,
         {
@@ -279,7 +329,7 @@ export async function POST(req: Request) {
         }
       }
 
-      await saveEmbeddingConfig(container, change.newConfig)
+      await saveEmbeddingConfig(container, change.newConfig, { scope: { tenantId: auth.tenantId } })
       embeddingConfig = change.newConfig
 
       try {
@@ -296,7 +346,7 @@ export async function POST(req: Request) {
     let autoIndexingEnabled = !lockedByEnv
     if (!lockedByEnv) {
       try {
-        autoIndexingEnabled = await resolveAutoIndexingEnabled(container, { defaultValue: true })
+        autoIndexingEnabled = await resolveAutoIndexingEnabled(container, { defaultValue: true, scope: { tenantId: auth.tenantId } })
       } catch {
         autoIndexingEnabled = true
       }
@@ -307,6 +357,10 @@ export async function POST(req: Request) {
       ? await getVectorDocumentCount(container, auth.tenantId, auth.orgId)
       : null
 
+    const { source: embeddingConfigSource } = await resolveEmbeddingConfigResult(container, {
+      scope: { tenantId: auth.tenantId },
+    })
+
     return toJson({
       settings: {
         openaiConfigured: openAiConfigured(),
@@ -314,7 +368,9 @@ export async function POST(req: Request) {
         autoIndexingLocked: lockedByEnv,
         lockReason: lockedByEnv ? 'env' : null,
         embeddingConfig,
+        embeddingConfigSource,
         configuredProviders: getConfiguredProviders(),
+        providerAvailability: await resolveProviderAvailability(container),
         indexedDimension,
         reindexRequired,
         documentCount: updatedDocumentCount,

package/src/modules/search/api/search/global/route.ts

@@ -64,8 +64,8 @@ export async function GET(req: Request) {
       )
     }
 
-    // Fetch saved global search strategies
-    const strategies = await resolveGlobalSearchStrategies(container)
+    // Fetch saved global search strategies (per-tenant; falls back to the instance default)
+    const strategies = await resolveGlobalSearchStrategies(container, { scope: { tenantId: auth.tenantId } })
 
     // Load embedding config for vector strategy (only if vector is enabled)
     if (strategies.includes('vector')) {

package/src/modules/search/api/settings/global-search/route.ts

@@ -4,10 +4,11 @@ import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
 import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
 import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
 import {
-  resolveGlobalSearchStrategies,
+  resolveGlobalSearchStrategiesResult,
   saveGlobalSearchStrategies,
   DEFAULT_GLOBAL_SEARCH_STRATEGIES,
 } from '../../../lib/global-search-config'
+import type { GlobalSearchSource } from '../../../lib/global-search-config'
 import type { SearchStrategyId } from '@open-mercato/shared/modules/search'
 import { globalSearchSettingsOpenApi } from '../../openapi'
 
@@ -22,6 +23,7 @@ export const metadata = {
 
 type SettingsResponse = {
   enabledStrategies: SearchStrategyId[]
+  source?: GlobalSearchSource
 }
 
 const toJson = (payload: SettingsResponse, init?: ResponseInit) => NextResponse.json(payload, init)
@@ -37,11 +39,12 @@ export async function GET(req: Request) {
 
   const container = await createRequestContainer()
   try {
-    const enabledStrategies = await resolveGlobalSearchStrategies(container, {
+    const { strategies: enabledStrategies, source } = await resolveGlobalSearchStrategiesResult(container, {
       defaultValue: DEFAULT_GLOBAL_SEARCH_STRATEGIES,
+      scope: { tenantId: auth.tenantId },
     })
 
-    return toJson({ enabledStrategies })
+    return toJson({ enabledStrategies, source })
   } finally {
     const disposable = container as unknown as { dispose?: () => Promise<void> }
     if (typeof disposable.dispose === 'function') {
@@ -75,7 +78,9 @@ export async function POST(req: Request) {
 
   const container = await createRequestContainer()
   try {
-    await saveGlobalSearchStrategies(container, parsed.data.enabledStrategies)
+    await saveGlobalSearchStrategies(container, parsed.data.enabledStrategies, {
+      scope: { tenantId: auth.tenantId },
+    })
 
     return NextResponse.json({ ok: true, enabledStrategies: parsed.data.enabledStrategies })
   } catch (error) {

package/src/modules/search/di.ts

@@ -4,6 +4,7 @@ import { getRedisUrlOrThrow } from '@open-mercato/shared/lib/redis/connection'
 import { EmbeddingService, createPgVectorDriver, createChromaDbDriver, createQdrantDriver } from '../../vector'
 import { createVectorIndexingQueue, type VectorIndexJobPayload } from '../../queue/vector-indexing'
 import { createFulltextIndexingQueue, type FulltextIndexJobPayload } from '../../queue/fulltext-indexing'
+import { createEmbeddingProviderProbe } from './lib/provider-probe'
 import type { Queue } from '@open-mercato/queue'
 
 /**
@@ -47,5 +48,6 @@ export function register(container: AppContainer) {
     vectorDrivers: asValue(drivers),
     vectorIndexQueue: asValue(vectorIndexQueue),
     fulltextIndexQueue: asValue(fulltextIndexQueue),
+    embeddingProviderProbe: asValue(createEmbeddingProviderProbe(container)),
   })
 }