@open-mercato/ai-assistant 0.4.2-canary-c02407ff85

package/dist/modules/ai_assistant/lib/tool-index-config.js

@@ -0,0 +1,125 @@
+const TOOL_ENTITY_ID = "ai_assistant:mcp_tool";
+const GLOBAL_TENANT_ID = "00000000-0000-0000-0000-000000000000";
+const ESSENTIAL_TOOLS = [
+  "context_whoami",
+  // Auth context awareness
+  "search_query",
+  // Universal search
+  "search_schema",
+  // Entity discovery
+  "search_status"
+  // Check integrations
+];
+const TOOL_SEARCH_CONFIG = {
+  /** Maximum tools to return from search */
+  defaultLimit: 12,
+  /** Minimum relevance score (0-1) */
+  minScore: 0.2,
+  /** Strategies to use (in priority order) */
+  strategies: ["fulltext", "vector", "tokens"]
+};
+const toolSearchEntityConfig = {
+  entityId: TOOL_ENTITY_ID,
+  enabled: true,
+  priority: 100,
+  // High priority for tool results
+  /**
+   * Build searchable content from a tool definition.
+   */
+  buildSource: (ctx) => {
+    const tool = ctx.record;
+    const name = tool.name || "";
+    const description = tool.description || "";
+    const moduleId = ctx.record.moduleId;
+    const normalizedName = name.replace(/[_.-]/g, " ");
+    const textContent = [
+      normalizedName,
+      description,
+      moduleId ? `module ${moduleId}` : ""
+    ].filter(Boolean).join(" | ");
+    return {
+      text: textContent,
+      fields: {
+        name: normalizedName,
+        originalName: name,
+        description,
+        moduleId: moduleId ?? null,
+        requiredFeatures: tool.requiredFeatures ?? []
+      },
+      presenter: {
+        title: name,
+        subtitle: description.slice(0, 100),
+        icon: "tool"
+      },
+      checksumSource: { name, description, moduleId }
+    };
+  },
+  /**
+   * Format result for display in search UI.
+   */
+  formatResult: (ctx) => {
+    const tool = ctx.record;
+    return {
+      title: tool.name || "Unknown Tool",
+      subtitle: (tool.description || "").slice(0, 100),
+      icon: "tool"
+    };
+  },
+  /**
+   * Field policy for search strategies.
+   */
+  fieldPolicy: {
+    searchable: ["name", "description", "moduleId"],
+    hashOnly: [],
+    excluded: ["requiredFeatures", "inputSchema", "handler"]
+  }
+};
+function toolToIndexableRecord(tool, moduleId) {
+  const normalizedName = tool.name.replace(/[_.-]/g, " ");
+  const description = tool.description || "";
+  const embeddingText = `${normalizedName} | ${description}`;
+  const presenter = {
+    title: tool.name,
+    subtitle: description.slice(0, 100),
+    icon: "tool"
+  };
+  return {
+    entityId: TOOL_ENTITY_ID,
+    recordId: tool.name,
+    tenantId: GLOBAL_TENANT_ID,
+    organizationId: null,
+    fields: {
+      name: normalizedName,
+      originalName: tool.name,
+      description,
+      moduleId: moduleId ?? null,
+      requiredFeatures: tool.requiredFeatures ?? []
+    },
+    presenter,
+    text: embeddingText,
+    checksumSource: {
+      name: tool.name,
+      description,
+      moduleId
+    }
+  };
+}
+function computeToolsChecksum(tools) {
+  const content = tools.map((t) => `${t.name}:${t.description}`).sort().join("|");
+  let hash = 0;
+  for (let i = 0; i < content.length; i++) {
+    const char = content.charCodeAt(i);
+    hash = (hash << 5) - hash + char | 0;
+  }
+  return hash.toString(16);
+}
+export {
+  ESSENTIAL_TOOLS,
+  GLOBAL_TENANT_ID,
+  TOOL_ENTITY_ID,
+  TOOL_SEARCH_CONFIG,
+  computeToolsChecksum,
+  toolSearchEntityConfig,
+  toolToIndexableRecord
+};
+//# sourceMappingURL=tool-index-config.js.map

package/dist/modules/ai_assistant/lib/tool-index-config.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/ai_assistant/lib/tool-index-config.ts"],
+  "sourcesContent": ["import type {\n  SearchEntityConfig,\n  SearchResultPresenter,\n  IndexableRecord,\n} from '@open-mercato/search/types'\nimport type { McpToolDefinition } from './types'\n\n/**\n * Entity ID for MCP tools in the search index.\n * Following the module:entity naming convention.\n */\nexport const TOOL_ENTITY_ID = 'ai_assistant:mcp_tool' as const\n\n/**\n * Tenant ID for global tools.\n * Tools are not tenant-scoped, so we use a special \"system\" UUID.\n * This is the nil UUID (all zeros) reserved for system-wide resources.\n */\nexport const GLOBAL_TENANT_ID = '00000000-0000-0000-0000-000000000000'\n\n/**\n * Essential tools that should always be available regardless of search results.\n * These provide fundamental functionality for the AI assistant.\n */\nexport const ESSENTIAL_TOOLS = [\n  'context_whoami', // Auth context awareness\n  'search_query', // Universal search\n  'search_schema', // Entity discovery\n  'search_status', // Check integrations\n] as const\n\n/**\n * Default configuration for tool search.\n */\nexport const TOOL_SEARCH_CONFIG = {\n  /** Maximum tools to return from search */\n  defaultLimit: 12,\n  /** Minimum relevance score (0-1) */\n  minScore: 0.2,\n  /** Strategies to use (in priority order) */\n  strategies: ['fulltext', 'vector', 'tokens'] as const,\n} as const\n\n/**\n * Search entity configuration for MCP tools.\n * This configures how tools are indexed and searched.\n */\nexport const toolSearchEntityConfig: SearchEntityConfig = {\n  entityId: TOOL_ENTITY_ID,\n  enabled: true,\n  priority: 100, // High priority for tool results\n\n  /**\n   * Build searchable content from a tool definition.\n   */\n  buildSource: (ctx) => {\n    const tool = ctx.record as unknown as McpToolDefinition\n    const name = tool.name || ''\n    const description = tool.description || ''\n    const moduleId = (ctx.record as Record<string, unknown>).moduleId as string | undefined\n\n    // Normalize name: replace underscores/dots with spaces for better search\n    const normalizedName = name.replace(/[_.-]/g, ' ')\n\n    // Build text content for embedding and fulltext search\n    const textContent = [\n      normalizedName,\n      description,\n      moduleId ? `module ${moduleId}` : '',\n    ]\n      .filter(Boolean)\n      .join(' | ')\n\n    return {\n      text: textContent,\n      fields: {\n        name: normalizedName,\n        originalName: name,\n        description,\n        moduleId: moduleId ?? null,\n        requiredFeatures: tool.requiredFeatures ?? [],\n      },\n      presenter: {\n        title: name,\n        subtitle: description.slice(0, 100),\n        icon: 'tool',\n      },\n      checksumSource: { name, description, moduleId },\n    }\n  },\n\n  /**\n   * Format result for display in search UI.\n   */\n  formatResult: (ctx) => {\n    const tool = ctx.record as unknown as McpToolDefinition\n    return {\n      title: tool.name || 'Unknown Tool',\n      subtitle: (tool.description || '').slice(0, 100),\n      icon: 'tool',\n    }\n  },\n\n  /**\n   * Field policy for search strategies.\n   */\n  fieldPolicy: {\n    searchable: ['name', 'description', 'moduleId'],\n    hashOnly: [],\n    excluded: ['requiredFeatures', 'inputSchema', 'handler'],\n  },\n}\n\n/**\n * Convert an MCP tool definition to an indexable record for search.\n *\n * @param tool - The tool definition to index\n * @param moduleId - The module that registered this tool\n * @returns IndexableRecord ready for search indexing\n */\nexport function toolToIndexableRecord(\n  tool: McpToolDefinition,\n  moduleId?: string\n): IndexableRecord {\n  const normalizedName = tool.name.replace(/[_.-]/g, ' ')\n  const description = tool.description || ''\n\n  // Build text for vector embedding\n  const embeddingText = `${normalizedName} | ${description}`\n\n  const presenter: SearchResultPresenter = {\n    title: tool.name,\n    subtitle: description.slice(0, 100),\n    icon: 'tool',\n  }\n\n  return {\n    entityId: TOOL_ENTITY_ID,\n    recordId: tool.name,\n    tenantId: GLOBAL_TENANT_ID,\n    organizationId: null,\n    fields: {\n      name: normalizedName,\n      originalName: tool.name,\n      description,\n      moduleId: moduleId ?? null,\n      requiredFeatures: tool.requiredFeatures ?? [],\n    },\n    presenter,\n    text: embeddingText,\n    checksumSource: {\n      name: tool.name,\n      description,\n      moduleId,\n    },\n  }\n}\n\n/**\n * Compute a simple checksum for tool definitions.\n * Used to detect changes and avoid unnecessary re-indexing.\n */\nexport function computeToolsChecksum(\n  tools: Array<{ name: string; description: string }>\n): string {\n  const content = tools\n    .map((t) => `${t.name}:${t.description}`)\n    .sort()\n    .join('|')\n\n  // Simple hash using string code points\n  let hash = 0\n  for (let i = 0; i < content.length; i++) {\n    const char = content.charCodeAt(i)\n    hash = ((hash << 5) - hash + char) | 0\n  }\n  return hash.toString(16)\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/modules/ai_assistant/lib/tool-loader.js

@@ -0,0 +1,88 @@
+import { z } from "zod";
+import { registerMcpTool, getToolRegistry } from "./tool-registry.js";
+import { ToolSearchService } from "./tool-search.js";
+import { loadApiDiscoveryTools } from "./api-discovery-tools.js";
+const contextWhoamiTool = {
+  name: "context_whoami",
+  description: "Get the current authentication context including tenant ID, organization ID, user ID, and available features. Use this to understand your current scope before performing operations.",
+  inputSchema: z.object({}),
+  requiredFeatures: [],
+  // No specific feature required - available to all authenticated users
+  handler: async (_input, ctx) => {
+    return {
+      tenantId: ctx.tenantId,
+      organizationId: ctx.organizationId,
+      userId: ctx.userId,
+      isSuperAdmin: ctx.isSuperAdmin,
+      features: ctx.userFeatures,
+      featureCount: ctx.userFeatures.length
+    };
+  }
+};
+function loadModuleTools(moduleId, tools) {
+  for (const tool of tools) {
+    registerMcpTool(
+      {
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        requiredFeatures: tool.requiredFeatures,
+        handler: tool.handler
+      },
+      { moduleId }
+    );
+  }
+}
+async function loadAllModuleTools() {
+  registerMcpTool(contextWhoamiTool, { moduleId: "context" });
+  console.error("[MCP Tools] Registered built-in context_whoami tool");
+  const moduleToolPaths = [
+    { moduleId: "search", importPath: "@open-mercato/search/modules/search/ai-tools" }
+    // Add more modules here as they define ai-tools.ts
+  ];
+  for (const { moduleId, importPath } of moduleToolPaths) {
+    try {
+      const module = await import(importPath);
+      const tools = module.aiTools ?? module.default ?? [];
+      if (Array.isArray(tools) && tools.length > 0) {
+        loadModuleTools(moduleId, tools);
+        console.error(`[MCP Tools] Loaded ${tools.length} tools from ${moduleId}`);
+      }
+    } catch (error) {
+      console.error(`[MCP Tools] Could not load tools from ${moduleId}:`, error);
+    }
+  }
+  try {
+    const apiToolCount = await loadApiDiscoveryTools();
+    console.error(`[MCP Tools] Loaded ${apiToolCount} API discovery tools`);
+  } catch (error) {
+    console.error("[MCP Tools] Could not load API discovery tools:", error);
+  }
+}
+async function indexToolsForSearch(searchService, force = false) {
+  const registry = getToolRegistry();
+  const toolSearchService = new ToolSearchService(searchService, registry);
+  try {
+    const result = await toolSearchService.indexTools(force);
+    console.error(`[MCP Tools] Indexed ${result.indexed} tools for search`);
+    console.error(`[MCP Tools] Search strategies available: ${result.strategies.join(", ")}`);
+    if (result.skipped > 0) {
+      console.error(`[MCP Tools] Skipped ${result.skipped} tools (unchanged)`);
+    }
+    return result;
+  } catch (error) {
+    console.error("[MCP Tools] Failed to index tools for search:", error);
+    throw error;
+  }
+}
+function createToolSearchService(searchService) {
+  const registry = getToolRegistry();
+  return new ToolSearchService(searchService, registry);
+}
+export {
+  createToolSearchService,
+  indexToolsForSearch,
+  loadAllModuleTools,
+  loadModuleTools
+};
+//# sourceMappingURL=tool-loader.js.map

package/dist/modules/ai_assistant/lib/tool-loader.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/ai_assistant/lib/tool-loader.ts"],
+  "sourcesContent": ["import { z } from 'zod'\nimport type { SearchService } from '@open-mercato/search/service'\nimport { registerMcpTool, getToolRegistry } from './tool-registry'\nimport type { McpToolDefinition, McpToolContext } from './types'\nimport { ToolSearchService } from './tool-search'\nimport { loadApiDiscoveryTools } from './api-discovery-tools'\n\n/**\n * Module tool definition as exported from ai-tools.ts files.\n */\ntype ModuleAiTool = {\n  name: string\n  description: string\n  inputSchema: any\n  requiredFeatures?: string[]\n  handler: (input: any, ctx: any) => Promise<unknown>\n}\n\n/**\n * Built-in context.whoami tool that returns the current authentication context.\n * This is useful for AI to understand its current tenant/org scope.\n */\nconst contextWhoamiTool: McpToolDefinition = {\n  name: 'context_whoami',\n  description:\n    'Get the current authentication context including tenant ID, organization ID, user ID, and available features. Use this to understand your current scope before performing operations.',\n  inputSchema: z.object({}),\n  requiredFeatures: [], // No specific feature required - available to all authenticated users\n  handler: async (_input: unknown, ctx: McpToolContext) => {\n    return {\n      tenantId: ctx.tenantId,\n      organizationId: ctx.organizationId,\n      userId: ctx.userId,\n      isSuperAdmin: ctx.isSuperAdmin,\n      features: ctx.userFeatures,\n      featureCount: ctx.userFeatures.length,\n    }\n  },\n}\n\n/**\n * Load and register AI tools from a module's ai-tools.ts export.\n *\n * @param moduleId - The module identifier (e.g., 'search', 'customers')\n * @param tools - Array of tool definitions from the module\n */\nexport function loadModuleTools(moduleId: string, tools: ModuleAiTool[]): void {\n  for (const tool of tools) {\n    registerMcpTool(\n      {\n        name: tool.name,\n        description: tool.description,\n        inputSchema: tool.inputSchema,\n        requiredFeatures: tool.requiredFeatures,\n        handler: tool.handler,\n      } as McpToolDefinition,\n      { moduleId }\n    )\n  }\n}\n\n/**\n * Dynamically load tools from known module paths.\n * This is called during MCP server startup.\n */\nexport async function loadAllModuleTools(): Promise<void> {\n  // 1. Register built-in tools\n  registerMcpTool(contextWhoamiTool, { moduleId: 'context' })\n  console.error('[MCP Tools] Registered built-in context_whoami tool')\n\n  // 2. Load manual ai-tools.ts files from modules\n  const moduleToolPaths = [\n    { moduleId: 'search', importPath: '@open-mercato/search/modules/search/ai-tools' },\n    // Add more modules here as they define ai-tools.ts\n  ]\n\n  for (const { moduleId, importPath } of moduleToolPaths) {\n    try {\n      const module = await import(importPath)\n      const tools = module.aiTools ?? module.default ?? []\n\n      if (Array.isArray(tools) && tools.length > 0) {\n        loadModuleTools(moduleId, tools)\n        console.error(`[MCP Tools] Loaded ${tools.length} tools from ${moduleId}`)\n      }\n    } catch (error) {\n      // Module might not have ai-tools.ts or import failed\n      // This is not an error - modules can optionally provide tools\n      console.error(`[MCP Tools] Could not load tools from ${moduleId}:`, error)\n    }\n  }\n\n  // 3. Load API discovery tools (api_discover, api_execute, api_schema)\n  try {\n    const apiToolCount = await loadApiDiscoveryTools()\n    console.error(`[MCP Tools] Loaded ${apiToolCount} API discovery tools`)\n  } catch (error) {\n    console.error('[MCP Tools] Could not load API discovery tools:', error)\n  }\n}\n\n/**\n * Index all registered tools for hybrid search discovery.\n * This should be called after loadAllModuleTools() when the search service is available.\n *\n * @param searchService - The search service from DI container\n * @param force - Force re-indexing even if checksums match\n * @returns Indexing result with statistics\n */\nexport async function indexToolsForSearch(\n  searchService: SearchService,\n  force = false\n): Promise<{\n  indexed: number\n  skipped: number\n  strategies: string[]\n  checksum: string\n}> {\n  const registry = getToolRegistry()\n  const toolSearchService = new ToolSearchService(searchService, registry)\n\n  try {\n    const result = await toolSearchService.indexTools(force)\n\n    console.error(`[MCP Tools] Indexed ${result.indexed} tools for search`)\n    console.error(`[MCP Tools] Search strategies available: ${result.strategies.join(', ')}`)\n\n    if (result.skipped > 0) {\n      console.error(`[MCP Tools] Skipped ${result.skipped} tools (unchanged)`)\n    }\n\n    return result\n  } catch (error) {\n    console.error('[MCP Tools] Failed to index tools for search:', error)\n    throw error\n  }\n}\n\n/**\n * Create a ToolSearchService instance for tool discovery.\n * Use this to get a configured service for discovering relevant tools.\n *\n * @param searchService - The search service from DI container\n * @returns Configured ToolSearchService\n */\nexport function createToolSearchService(searchService: SearchService): ToolSearchService {\n  const registry = getToolRegistry()\n  return new ToolSearchService(searchService, registry)\n}\n"],
+  "mappings": "AAAA,SAAS,SAAS;AAElB,SAAS,iBAAiB,uBAAuB;AAEjD,SAAS,yBAAyB;AAClC,SAAS,6BAA6B;AAiBtC,MAAM,oBAAuC;AAAA,EAC3C,MAAM;AAAA,EACN,aACE;AAAA,EACF,aAAa,EAAE,OAAO,CAAC,CAAC;AAAA,EACxB,kBAAkB,CAAC;AAAA;AAAA,EACnB,SAAS,OAAO,QAAiB,QAAwB;AACvD,WAAO;AAAA,MACL,UAAU,IAAI;AAAA,MACd,gBAAgB,IAAI;AAAA,MACpB,QAAQ,IAAI;AAAA,MACZ,cAAc,IAAI;AAAA,MAClB,UAAU,IAAI;AAAA,MACd,cAAc,IAAI,aAAa;AAAA,IACjC;AAAA,EACF;AACF;AAQO,SAAS,gBAAgB,UAAkB,OAA6B;AAC7E,aAAW,QAAQ,OAAO;AACxB;AAAA,MACE;AAAA,QACE,MAAM,KAAK;AAAA,QACX,aAAa,KAAK;AAAA,QAClB,aAAa,KAAK;AAAA,QAClB,kBAAkB,KAAK;AAAA,QACvB,SAAS,KAAK;AAAA,MAChB;AAAA,MACA,EAAE,SAAS;AAAA,IACb;AAAA,EACF;AACF;AAMA,eAAsB,qBAAoC;AAExD,kBAAgB,mBAAmB,EAAE,UAAU,UAAU,CAAC;AAC1D,UAAQ,MAAM,qDAAqD;AAGnE,QAAM,kBAAkB;AAAA,IACtB,EAAE,UAAU,UAAU,YAAY,+CAA+C;AAAA;AAAA,EAEnF;AAEA,aAAW,EAAE,UAAU,WAAW,KAAK,iBAAiB;AACtD,QAAI;AACF,YAAM,SAAS,MAAM,OAAO;AAC5B,YAAM,QAAQ,OAAO,WAAW,OAAO,WAAW,CAAC;AAEnD,UAAI,MAAM,QAAQ,KAAK,KAAK,MAAM,SAAS,GAAG;AAC5C,wBAAgB,UAAU,KAAK;AAC/B,gBAAQ,MAAM,sBAAsB,MAAM,MAAM,eAAe,QAAQ,EAAE;AAAA,MAC3E;AAAA,IACF,SAAS,OAAO;AAGd,cAAQ,MAAM,yCAAyC,QAAQ,KAAK,KAAK;AAAA,IAC3E;AAAA,EACF;AAGA,MAAI;AACF,UAAM,eAAe,MAAM,sBAAsB;AACjD,YAAQ,MAAM,sBAAsB,YAAY,sBAAsB;AAAA,EACxE,SAAS,OAAO;AACd,YAAQ,MAAM,mDAAmD,KAAK;AAAA,EACxE;AACF;AAUA,eAAsB,oBACpB,eACA,QAAQ,OAMP;AACD,QAAM,WAAW,gBAAgB;AACjC,QAAM,oBAAoB,IAAI,kBAAkB,eAAe,QAAQ;AAEvE,MAAI;AACF,UAAM,SAAS,MAAM,kBAAkB,WAAW,KAAK;AAEvD,YAAQ,MAAM,uBAAuB,OAAO,OAAO,mBAAmB;AACtE,YAAQ,MAAM,4CAA4C,OAAO,WAAW,KAAK,IAAI,CAAC,EAAE;AAExF,QAAI,OAAO,UAAU,GAAG;AACtB,cAAQ,MAAM,uBAAuB,OAAO,OAAO,oBAAoB;AAAA,IACzE;AAEA,WAAO;AAAA,EACT,SAAS,OAAO;AACd,YAAQ,MAAM,iDAAiD,KAAK;AACpE,UAAM;AAAA,EACR;AACF;AASO,SAAS,wBAAwB,eAAiD;AACvF,QAAM,WAAW,gBAAgB;AACjC,SAAO,IAAI,kBAAkB,eAAe,QAAQ;AACtD;",
+  "names": []
+}

package/dist/modules/ai_assistant/lib/tool-registry.js

@@ -0,0 +1,65 @@
+class ToolRegistryImpl {
+  constructor() {
+    this.tools = /* @__PURE__ */ new Map();
+    this.moduleMap = /* @__PURE__ */ new Map();
+  }
+  registerTool(tool, options) {
+    if (!tool?.name) {
+      throw new Error("MCP tool must define a name");
+    }
+    if (this.tools.has(tool.name)) {
+      console.warn(`[McpToolRegistry] Tool "${tool.name}" already registered, overwriting`);
+    }
+    this.tools.set(tool.name, tool);
+    if (options?.moduleId) {
+      const existing = this.moduleMap.get(options.moduleId) ?? [];
+      if (!existing.includes(tool.name)) {
+        existing.push(tool.name);
+      }
+      this.moduleMap.set(options.moduleId, existing);
+    }
+  }
+  getTools() {
+    return new Map(this.tools);
+  }
+  getTool(name) {
+    return this.tools.get(name);
+  }
+  listToolNames() {
+    return Array.from(this.tools.keys());
+  }
+  listToolsByModule(moduleId) {
+    return this.moduleMap.get(moduleId) ?? [];
+  }
+  unregisterTool(name) {
+    this.tools.delete(name);
+    for (const [moduleId, tools] of this.moduleMap.entries()) {
+      const index = tools.indexOf(name);
+      if (index !== -1) {
+        tools.splice(index, 1);
+        this.moduleMap.set(moduleId, tools);
+      }
+    }
+  }
+  clear() {
+    this.tools.clear();
+    this.moduleMap.clear();
+  }
+}
+const toolRegistry = new ToolRegistryImpl();
+function registerMcpTool(tool, options) {
+  toolRegistry.registerTool(tool, options);
+}
+function getToolRegistry() {
+  return toolRegistry;
+}
+function unregisterMcpTool(name) {
+  toolRegistry.unregisterTool(name);
+}
+export {
+  getToolRegistry,
+  registerMcpTool,
+  toolRegistry,
+  unregisterMcpTool
+};
+//# sourceMappingURL=tool-registry.js.map

package/dist/modules/ai_assistant/lib/tool-registry.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/ai_assistant/lib/tool-registry.ts"],
+  "sourcesContent": ["import type { McpToolDefinition, McpToolRegistry, ToolRegistrationOptions } from './types'\n\n/**\n * Global tool registry singleton.\n * Modules call registerMcpTool() to add their tools.\n */\nclass ToolRegistryImpl implements McpToolRegistry {\n  private tools = new Map<string, McpToolDefinition>()\n  private moduleMap = new Map<string, string[]>()\n\n  registerTool<TInput, TOutput>(\n    tool: McpToolDefinition<TInput, TOutput>,\n    options?: ToolRegistrationOptions\n  ): void {\n    if (!tool?.name) {\n      throw new Error('MCP tool must define a name')\n    }\n\n    if (this.tools.has(tool.name)) {\n      console.warn(`[McpToolRegistry] Tool \"${tool.name}\" already registered, overwriting`)\n    }\n\n    this.tools.set(tool.name, tool as McpToolDefinition)\n\n    if (options?.moduleId) {\n      const existing = this.moduleMap.get(options.moduleId) ?? []\n      if (!existing.includes(tool.name)) {\n        existing.push(tool.name)\n      }\n      this.moduleMap.set(options.moduleId, existing)\n    }\n  }\n\n  getTools(): Map<string, McpToolDefinition> {\n    return new Map(this.tools)\n  }\n\n  getTool(name: string): McpToolDefinition | undefined {\n    return this.tools.get(name)\n  }\n\n  listToolNames(): string[] {\n    return Array.from(this.tools.keys())\n  }\n\n  listToolsByModule(moduleId: string): string[] {\n    return this.moduleMap.get(moduleId) ?? []\n  }\n\n  unregisterTool(name: string): void {\n    this.tools.delete(name)\n    for (const [moduleId, tools] of this.moduleMap.entries()) {\n      const index = tools.indexOf(name)\n      if (index !== -1) {\n        tools.splice(index, 1)\n        this.moduleMap.set(moduleId, tools)\n      }\n    }\n  }\n\n  clear(): void {\n    this.tools.clear()\n    this.moduleMap.clear()\n  }\n}\n\nexport const toolRegistry = new ToolRegistryImpl()\n\n/**\n * Register an MCP tool from any module.\n *\n * Note: Tool names must match the pattern ^[a-zA-Z0-9_-]{1,128}$\n * (no dots allowed - use underscores instead).\n *\n * @example\n * ```typescript\n * import { registerMcpTool } from '@open-mercato/ai-assistant/tools'\n * import { z } from 'zod'\n *\n * registerMcpTool({\n *   name: 'customers_search',\n *   description: 'Search for customers by name or email',\n *   inputSchema: z.object({\n *     query: z.string(),\n *     limit: z.number().optional().default(10),\n *   }),\n *   requiredFeatures: ['customers.people.view'],\n *   handler: async (input, ctx) => {\n *     const queryEngine = ctx.container.resolve('queryEngine')\n *     // ... implementation\n *   }\n * }, { moduleId: 'customers' })\n * ```\n */\nexport function registerMcpTool<TInput, TOutput>(\n  tool: McpToolDefinition<TInput, TOutput>,\n  options?: ToolRegistrationOptions\n): void {\n  toolRegistry.registerTool(tool, options)\n}\n\n/**\n * Get the global tool registry instance.\n */\nexport function getToolRegistry(): McpToolRegistry {\n  return toolRegistry\n}\n\n/**\n * Unregister an MCP tool by name.\n */\nexport function unregisterMcpTool(name: string): void {\n  toolRegistry.unregisterTool(name)\n}\n"],
+  "mappings": "AAMA,MAAM,iBAA4C;AAAA,EAAlD;AACE,SAAQ,QAAQ,oBAAI,IAA+B;AACnD,SAAQ,YAAY,oBAAI,IAAsB;AAAA;AAAA,EAE9C,aACE,MACA,SACM;AACN,QAAI,CAAC,MAAM,MAAM;AACf,YAAM,IAAI,MAAM,6BAA6B;AAAA,IAC/C;AAEA,QAAI,KAAK,MAAM,IAAI,KAAK,IAAI,GAAG;AAC7B,cAAQ,KAAK,2BAA2B,KAAK,IAAI,mCAAmC;AAAA,IACtF;AAEA,SAAK,MAAM,IAAI,KAAK,MAAM,IAAyB;AAEnD,QAAI,SAAS,UAAU;AACrB,YAAM,WAAW,KAAK,UAAU,IAAI,QAAQ,QAAQ,KAAK,CAAC;AAC1D,UAAI,CAAC,SAAS,SAAS,KAAK,IAAI,GAAG;AACjC,iBAAS,KAAK,KAAK,IAAI;AAAA,MACzB;AACA,WAAK,UAAU,IAAI,QAAQ,UAAU,QAAQ;AAAA,IAC/C;AAAA,EACF;AAAA,EAEA,WAA2C;AACzC,WAAO,IAAI,IAAI,KAAK,KAAK;AAAA,EAC3B;AAAA,EAEA,QAAQ,MAA6C;AACnD,WAAO,KAAK,MAAM,IAAI,IAAI;AAAA,EAC5B;AAAA,EAEA,gBAA0B;AACxB,WAAO,MAAM,KAAK,KAAK,MAAM,KAAK,CAAC;AAAA,EACrC;AAAA,EAEA,kBAAkB,UAA4B;AAC5C,WAAO,KAAK,UAAU,IAAI,QAAQ,KAAK,CAAC;AAAA,EAC1C;AAAA,EAEA,eAAe,MAAoB;AACjC,SAAK,MAAM,OAAO,IAAI;AACtB,eAAW,CAAC,UAAU,KAAK,KAAK,KAAK,UAAU,QAAQ,GAAG;AACxD,YAAM,QAAQ,MAAM,QAAQ,IAAI;AAChC,UAAI,UAAU,IAAI;AAChB,cAAM,OAAO,OAAO,CAAC;AACrB,aAAK,UAAU,IAAI,UAAU,KAAK;AAAA,MACpC;AAAA,IACF;AAAA,EACF;AAAA,EAEA,QAAc;AACZ,SAAK,MAAM,MAAM;AACjB,SAAK,UAAU,MAAM;AAAA,EACvB;AACF;AAEO,MAAM,eAAe,IAAI,iBAAiB;AA4B1C,SAAS,gBACd,MACA,SACM;AACN,eAAa,aAAa,MAAM,OAAO;AACzC;AAKO,SAAS,kBAAmC;AACjD,SAAO;AACT;AAKO,SAAS,kBAAkB,MAAoB;AACpD,eAAa,eAAe,IAAI;AAClC;",
+  "names": []
+}

package/dist/modules/ai_assistant/lib/tool-search.js

@@ -0,0 +1,192 @@
+import {
+  TOOL_ENTITY_ID,
+  GLOBAL_TENANT_ID,
+  TOOL_SEARCH_CONFIG,
+  toolToIndexableRecord,
+  computeToolsChecksum
+} from "./tool-index-config.js";
+class ToolSearchService {
+  constructor(searchService, toolRegistry) {
+    this.searchService = searchService;
+    this.toolRegistry = toolRegistry;
+    this.lastIndexChecksum = null;
+  }
+  /**
+   * Get status of available search strategies.
+   * This helps the AI understand which integrations are available.
+   */
+  async getStrategyStatus() {
+    const [fulltext, vector, tokens] = await Promise.all([
+      this.searchService.isStrategyAvailable("fulltext"),
+      this.searchService.isStrategyAvailable("vector"),
+      this.searchService.isStrategyAvailable("tokens")
+    ]);
+    const available = [];
+    if (fulltext) available.push("fulltext");
+    if (vector) available.push("vector");
+    if (tokens) available.push("tokens");
+    const defaultStrategies = this.searchService.getDefaultStrategies();
+    return {
+      fulltext,
+      vector,
+      tokens,
+      available,
+      default: defaultStrategies.filter((s) => available.includes(s))
+    };
+  }
+  /**
+   * Search for relevant tools using hybrid strategies.
+   *
+   * @param query - User's search query or message
+   * @param options - Search options
+   * @returns Array of matching tools sorted by relevance
+   */
+  async searchTools(query, options = {}) {
+    const {
+      limit = TOOL_SEARCH_CONFIG.defaultLimit,
+      strategies,
+      userFeatures = [],
+      isSuperAdmin = false,
+      minScore = TOOL_SEARCH_CONFIG.minScore
+    } = options;
+    const searchResults = await this.searchService.search(query, {
+      tenantId: GLOBAL_TENANT_ID,
+      organizationId: null,
+      entityTypes: [TOOL_ENTITY_ID],
+      strategies,
+      limit: limit * 2
+      // Get extra results to account for ACL filtering
+    });
+    const toolResults = [];
+    for (const result of searchResults) {
+      if (result.score < minScore) continue;
+      const metadata = result.metadata;
+      const requiredFeatures = metadata?.requiredFeatures ?? [];
+      const moduleId = metadata?.moduleId;
+      if (!this.hasFeatureAccess(requiredFeatures, userFeatures, isSuperAdmin)) {
+        continue;
+      }
+      toolResults.push({
+        toolName: result.recordId,
+        score: result.score,
+        moduleId,
+        requiredFeatures
+      });
+      if (toolResults.length >= limit) break;
+    }
+    return toolResults;
+  }
+  /**
+   * Index all tools from the registry using available strategies.
+   * Uses checksum-based change detection to avoid unnecessary re-indexing.
+   *
+   * @param force - Force re-indexing even if checksum hasn't changed
+   * @returns Indexing result with statistics
+   */
+  async indexTools(force = false) {
+    const tools = Array.from(this.toolRegistry.getTools().values());
+    const modules = this.getToolModules();
+    const checksum = computeToolsChecksum(
+      tools.map((t) => ({ name: t.name, description: t.description }))
+    );
+    if (!force && this.lastIndexChecksum === checksum) {
+      const status2 = await this.getStrategyStatus();
+      return {
+        indexed: 0,
+        skipped: tools.length,
+        strategies: status2.available,
+        checksum
+      };
+    }
+    const records = [];
+    for (const tool of tools) {
+      const moduleId = modules.get(tool.name);
+      records.push(toolToIndexableRecord(tool, moduleId));
+    }
+    if (records.length > 0) {
+      await this.searchService.bulkIndex(records);
+    }
+    this.lastIndexChecksum = checksum;
+    const status = await this.getStrategyStatus();
+    return {
+      indexed: records.length,
+      skipped: 0,
+      strategies: status.available,
+      checksum
+    };
+  }
+  /**
+   * Purge all tool records from the search index.
+   * Useful for cleanup or complete re-indexing.
+   */
+  async purgeIndex() {
+    await this.searchService.purge(TOOL_ENTITY_ID, GLOBAL_TENANT_ID);
+    this.lastIndexChecksum = null;
+  }
+  /**
+   * Get tools by module ID from the registry.
+   */
+  getToolsByModule(moduleId) {
+    return this.toolRegistry.listToolsByModule(moduleId);
+  }
+  /**
+   * Build a map of tool name to module ID.
+   */
+  getToolModules() {
+    const modules = /* @__PURE__ */ new Map();
+    const modulePatterns = [
+      { pattern: /^customers_/, moduleId: "customers" },
+      { pattern: /^sales_/, moduleId: "sales" },
+      { pattern: /^catalog_/, moduleId: "catalog" },
+      { pattern: /^staff_/, moduleId: "staff" },
+      { pattern: /^resources_/, moduleId: "resources" },
+      { pattern: /^planner/, moduleId: "planner" },
+      { pattern: /^search_/, moduleId: "search" },
+      { pattern: /^context_/, moduleId: "context" },
+      { pattern: /^auth_/, moduleId: "auth" },
+      { pattern: /^directory_/, moduleId: "directory" },
+      { pattern: /^dashboards_/, moduleId: "dashboards" },
+      { pattern: /^entities_/, moduleId: "entities" },
+      { pattern: /^dictionaries_/, moduleId: "dictionaries" },
+      { pattern: /^workflows_/, moduleId: "workflows" },
+      { pattern: /^business_rules_/, moduleId: "business_rules" },
+      { pattern: /^audit_logs_/, moduleId: "audit_logs" },
+      { pattern: /^attachments_/, moduleId: "attachments" },
+      { pattern: /^feature_toggles_/, moduleId: "feature_toggles" },
+      { pattern: /^currencies_/, moduleId: "currencies" },
+      { pattern: /^example_/, moduleId: "example" },
+      { pattern: /^cli_/, moduleId: "cli" }
+    ];
+    for (const toolName of this.toolRegistry.listToolNames()) {
+      for (const { pattern, moduleId } of modulePatterns) {
+        if (pattern.test(toolName)) {
+          modules.set(toolName, moduleId);
+          break;
+        }
+      }
+    }
+    return modules;
+  }
+  /**
+   * Check if user has required features to access a tool.
+   */
+  hasFeatureAccess(requiredFeatures, userFeatures, isSuperAdmin) {
+    if (isSuperAdmin) return true;
+    if (!requiredFeatures?.length) return true;
+    return requiredFeatures.every((required) => {
+      if (userFeatures.includes(required)) return true;
+      if (userFeatures.includes("*")) return true;
+      return userFeatures.some((feature) => {
+        if (feature.endsWith(".*")) {
+          const prefix = feature.slice(0, -2);
+          return required.startsWith(prefix + ".");
+        }
+        return false;
+      });
+    });
+  }
+}
+export {
+  ToolSearchService
+};
+//# sourceMappingURL=tool-search.js.map

package/dist/modules/ai_assistant/lib/tool-search.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/ai_assistant/lib/tool-search.ts"],
+  "sourcesContent": ["import type { SearchService } from '@open-mercato/search/service'\nimport type { SearchStrategyId, IndexableRecord } from '@open-mercato/search/types'\nimport type { McpToolRegistry, McpToolDefinition } from './types'\nimport {\n  TOOL_ENTITY_ID,\n  GLOBAL_TENANT_ID,\n  TOOL_SEARCH_CONFIG,\n  toolToIndexableRecord,\n  computeToolsChecksum,\n} from './tool-index-config'\n\n/**\n * Result from tool search.\n */\nexport type ToolSearchResult = {\n  /** Tool name (recordId) */\n  toolName: string\n  /** Relevance score */\n  score: number\n  /** Module that registered the tool */\n  moduleId?: string\n  /** Features required to use this tool */\n  requiredFeatures?: string[]\n}\n\n/**\n * Status of available search strategies.\n */\nexport type StrategyStatus = {\n  fulltext: boolean\n  vector: boolean\n  tokens: boolean\n  /** Ordered list of available strategies */\n  available: SearchStrategyId[]\n  /** Strategies that will be used by default */\n  default: SearchStrategyId[]\n}\n\n/**\n * Result from tool indexing operation.\n */\nexport type IndexingResult = {\n  indexed: number\n  skipped: number\n  strategies: SearchStrategyId[]\n  checksum: string\n}\n\n/**\n * Options for searching tools.\n */\nexport type ToolSearchOptions = {\n  /** Maximum results to return (default: 12) */\n  limit?: number\n  /** Override strategies to use */\n  strategies?: SearchStrategyId[]\n  /** User's features for ACL filtering */\n  userFeatures?: string[]\n  /** Is user a super admin (bypasses ACL) */\n  isSuperAdmin?: boolean\n  /** Minimum score threshold (default: 0.2) */\n  minScore?: number\n}\n\n/**\n * Service for searching and indexing MCP tools using hybrid search strategies.\n *\n * Uses the existing search module infrastructure to provide:\n * - Fulltext search (Meilisearch) when configured\n * - Vector/semantic search (PgVector) when configured\n * - Token-based search (PostgreSQL hash) as fallback\n *\n * Results are merged using Reciprocal Rank Fusion (RRF) with weights:\n * - fulltext: 1.2\n * - vector: 1.0\n * - tokens: 0.8\n */\nexport class ToolSearchService {\n  private lastIndexChecksum: string | null = null\n\n  constructor(\n    private readonly searchService: SearchService,\n    private readonly toolRegistry: McpToolRegistry\n  ) {}\n\n  /**\n   * Get status of available search strategies.\n   * This helps the AI understand which integrations are available.\n   */\n  async getStrategyStatus(): Promise<StrategyStatus> {\n    const [fulltext, vector, tokens] = await Promise.all([\n      this.searchService.isStrategyAvailable('fulltext'),\n      this.searchService.isStrategyAvailable('vector'),\n      this.searchService.isStrategyAvailable('tokens'),\n    ])\n\n    const available: SearchStrategyId[] = []\n    if (fulltext) available.push('fulltext')\n    if (vector) available.push('vector')\n    if (tokens) available.push('tokens')\n\n    const defaultStrategies = this.searchService.getDefaultStrategies()\n\n    return {\n      fulltext,\n      vector,\n      tokens,\n      available,\n      default: defaultStrategies.filter((s) => available.includes(s)),\n    }\n  }\n\n  /**\n   * Search for relevant tools using hybrid strategies.\n   *\n   * @param query - User's search query or message\n   * @param options - Search options\n   * @returns Array of matching tools sorted by relevance\n   */\n  async searchTools(\n    query: string,\n    options: ToolSearchOptions = {}\n  ): Promise<ToolSearchResult[]> {\n    const {\n      limit = TOOL_SEARCH_CONFIG.defaultLimit,\n      strategies,\n      userFeatures = [],\n      isSuperAdmin = false,\n      minScore = TOOL_SEARCH_CONFIG.minScore,\n    } = options\n\n    // Use hybrid search with all available strategies\n    const searchResults = await this.searchService.search(query, {\n      tenantId: GLOBAL_TENANT_ID,\n      organizationId: null,\n      entityTypes: [TOOL_ENTITY_ID],\n      strategies,\n      limit: limit * 2, // Get extra results to account for ACL filtering\n    })\n\n    // Map to tool results and filter by ACL\n    const toolResults: ToolSearchResult[] = []\n\n    for (const result of searchResults) {\n      // Skip results below minimum score\n      if (result.score < minScore) continue\n\n      const metadata = result.metadata as Record<string, unknown> | undefined\n      const requiredFeatures = (metadata?.requiredFeatures as string[]) ?? []\n      const moduleId = metadata?.moduleId as string | undefined\n\n      // Filter by user's feature access\n      if (!this.hasFeatureAccess(requiredFeatures, userFeatures, isSuperAdmin)) {\n        continue\n      }\n\n      toolResults.push({\n        toolName: result.recordId,\n        score: result.score,\n        moduleId,\n        requiredFeatures,\n      })\n\n      // Stop when we have enough results\n      if (toolResults.length >= limit) break\n    }\n\n    return toolResults\n  }\n\n  /**\n   * Index all tools from the registry using available strategies.\n   * Uses checksum-based change detection to avoid unnecessary re-indexing.\n   *\n   * @param force - Force re-indexing even if checksum hasn't changed\n   * @returns Indexing result with statistics\n   */\n  async indexTools(force = false): Promise<IndexingResult> {\n    const tools = Array.from(this.toolRegistry.getTools().values())\n    const modules = this.getToolModules()\n\n    // Compute checksum to detect changes\n    const checksum = computeToolsChecksum(\n      tools.map((t) => ({ name: t.name, description: t.description }))\n    )\n\n    // Skip if checksum matches and not forced\n    if (!force && this.lastIndexChecksum === checksum) {\n      const status = await this.getStrategyStatus()\n      return {\n        indexed: 0,\n        skipped: tools.length,\n        strategies: status.available,\n        checksum,\n      }\n    }\n\n    // Build indexable records for all tools\n    const records: IndexableRecord[] = []\n    for (const tool of tools) {\n      const moduleId = modules.get(tool.name)\n      records.push(toolToIndexableRecord(tool, moduleId))\n    }\n\n    // Bulk index using available strategies\n    if (records.length > 0) {\n      await this.searchService.bulkIndex(records)\n    }\n\n    // Update checksum\n    this.lastIndexChecksum = checksum\n\n    const status = await this.getStrategyStatus()\n    return {\n      indexed: records.length,\n      skipped: 0,\n      strategies: status.available,\n      checksum,\n    }\n  }\n\n  /**\n   * Purge all tool records from the search index.\n   * Useful for cleanup or complete re-indexing.\n   */\n  async purgeIndex(): Promise<void> {\n    await this.searchService.purge(TOOL_ENTITY_ID, GLOBAL_TENANT_ID)\n    this.lastIndexChecksum = null\n  }\n\n  /**\n   * Get tools by module ID from the registry.\n   */\n  getToolsByModule(moduleId: string): string[] {\n    return this.toolRegistry.listToolsByModule(moduleId)\n  }\n\n  /**\n   * Build a map of tool name to module ID.\n   */\n  private getToolModules(): Map<string, string> {\n    const modules = new Map<string, string>()\n\n    // Common module prefixes that indicate tool ownership\n    const modulePatterns = [\n      { pattern: /^customers_/, moduleId: 'customers' },\n      { pattern: /^sales_/, moduleId: 'sales' },\n      { pattern: /^catalog_/, moduleId: 'catalog' },\n      { pattern: /^staff_/, moduleId: 'staff' },\n      { pattern: /^resources_/, moduleId: 'resources' },\n      { pattern: /^planner/, moduleId: 'planner' },\n      { pattern: /^search_/, moduleId: 'search' },\n      { pattern: /^context_/, moduleId: 'context' },\n      { pattern: /^auth_/, moduleId: 'auth' },\n      { pattern: /^directory_/, moduleId: 'directory' },\n      { pattern: /^dashboards_/, moduleId: 'dashboards' },\n      { pattern: /^entities_/, moduleId: 'entities' },\n      { pattern: /^dictionaries_/, moduleId: 'dictionaries' },\n      { pattern: /^workflows_/, moduleId: 'workflows' },\n      { pattern: /^business_rules_/, moduleId: 'business_rules' },\n      { pattern: /^audit_logs_/, moduleId: 'audit_logs' },\n      { pattern: /^attachments_/, moduleId: 'attachments' },\n      { pattern: /^feature_toggles_/, moduleId: 'feature_toggles' },\n      { pattern: /^currencies_/, moduleId: 'currencies' },\n      { pattern: /^example_/, moduleId: 'example' },\n      { pattern: /^cli_/, moduleId: 'cli' },\n    ]\n\n    for (const toolName of this.toolRegistry.listToolNames()) {\n      for (const { pattern, moduleId } of modulePatterns) {\n        if (pattern.test(toolName)) {\n          modules.set(toolName, moduleId)\n          break\n        }\n      }\n    }\n\n    return modules\n  }\n\n  /**\n   * Check if user has required features to access a tool.\n   */\n  private hasFeatureAccess(\n    requiredFeatures: string[] | undefined,\n    userFeatures: string[],\n    isSuperAdmin: boolean\n  ): boolean {\n    if (isSuperAdmin) return true\n    if (!requiredFeatures?.length) return true\n\n    return requiredFeatures.every((required) => {\n      // Direct match\n      if (userFeatures.includes(required)) return true\n      // Wildcard match\n      if (userFeatures.includes('*')) return true\n\n      // Prefix wildcard match (e.g., 'customers.*' matches 'customers.people.view')\n      return userFeatures.some((feature) => {\n        if (feature.endsWith('.*')) {\n          const prefix = feature.slice(0, -2)\n          return required.startsWith(prefix + '.')\n        }\n        return false\n      })\n    })\n  }\n}\n"],
+  "mappings": "AAGA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAoEA,MAAM,kBAAkB;AAAA,EAG7B,YACmB,eACA,cACjB;AAFiB;AACA;AAJnB,SAAQ,oBAAmC;AAAA,EAKxC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMH,MAAM,oBAA6C;AACjD,UAAM,CAAC,UAAU,QAAQ,MAAM,IAAI,MAAM,QAAQ,IAAI;AAAA,MACnD,KAAK,cAAc,oBAAoB,UAAU;AAAA,MACjD,KAAK,cAAc,oBAAoB,QAAQ;AAAA,MAC/C,KAAK,cAAc,oBAAoB,QAAQ;AAAA,IACjD,CAAC;AAED,UAAM,YAAgC,CAAC;AACvC,QAAI,SAAU,WAAU,KAAK,UAAU;AACvC,QAAI,OAAQ,WAAU,KAAK,QAAQ;AACnC,QAAI,OAAQ,WAAU,KAAK,QAAQ;AAEnC,UAAM,oBAAoB,KAAK,cAAc,qBAAqB;AAElE,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,SAAS,kBAAkB,OAAO,CAAC,MAAM,UAAU,SAAS,CAAC,CAAC;AAAA,IAChE;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,MAAM,YACJ,OACA,UAA6B,CAAC,GACD;AAC7B,UAAM;AAAA,MACJ,QAAQ,mBAAmB;AAAA,MAC3B;AAAA,MACA,eAAe,CAAC;AAAA,MAChB,eAAe;AAAA,MACf,WAAW,mBAAmB;AAAA,IAChC,IAAI;AAGJ,UAAM,gBAAgB,MAAM,KAAK,cAAc,OAAO,OAAO;AAAA,MAC3D,UAAU;AAAA,MACV,gBAAgB;AAAA,MAChB,aAAa,CAAC,cAAc;AAAA,MAC5B;AAAA,MACA,OAAO,QAAQ;AAAA;AAAA,IACjB,CAAC;AAGD,UAAM,cAAkC,CAAC;AAEzC,eAAW,UAAU,eAAe;AAElC,UAAI,OAAO,QAAQ,SAAU;AAE7B,YAAM,WAAW,OAAO;AACxB,YAAM,mBAAoB,UAAU,oBAAiC,CAAC;AACtE,YAAM,WAAW,UAAU;AAG3B,UAAI,CAAC,KAAK,iBAAiB,kBAAkB,cAAc,YAAY,GAAG;AACxE;AAAA,MACF;AAEA,kBAAY,KAAK;AAAA,QACf,UAAU,OAAO;AAAA,QACjB,OAAO,OAAO;AAAA,QACd;AAAA,QACA;AAAA,MACF,CAAC;AAGD,UAAI,YAAY,UAAU,MAAO;AAAA,IACnC;AAEA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,MAAM,WAAW,QAAQ,OAAgC;AACvD,UAAM,QAAQ,MAAM,KAAK,KAAK,aAAa,SAAS,EAAE,OAAO,CAAC;AAC9D,UAAM,UAAU,KAAK,eAAe;AAGpC,UAAM,WAAW;AAAA,MACf,MAAM,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,EAAE,YAAY,EAAE;AAAA,IACjE;AAGA,QAAI,CAAC,SAAS,KAAK,sBAAsB,UAAU;AACjD,YAAMA,UAAS,MAAM,KAAK,kBAAkB;AAC5C,aAAO;AAAA,QACL,SAAS;AAAA,QACT,SAAS,MAAM;AAAA,QACf,YAAYA,QAAO;AAAA,QACnB;AAAA,MACF;AAAA,IACF;AAGA,UAAM,UAA6B,CAAC;AACpC,eAAW,QAAQ,OAAO;AACxB,YAAM,WAAW,QAAQ,IAAI,KAAK,IAAI;AACtC,cAAQ,KAAK,sBAAsB,MAAM,QAAQ,CAAC;AAAA,IACpD;AAGA,QAAI,QAAQ,SAAS,GAAG;AACtB,YAAM,KAAK,cAAc,UAAU,OAAO;AAAA,IAC5C;AAGA,SAAK,oBAAoB;AAEzB,UAAM,SAAS,MAAM,KAAK,kBAAkB;AAC5C,WAAO;AAAA,MACL,SAAS,QAAQ;AAAA,MACjB,SAAS;AAAA,MACT,YAAY,OAAO;AAAA,MACnB;AAAA,IACF;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,aAA4B;AAChC,UAAM,KAAK,cAAc,MAAM,gBAAgB,gBAAgB;AAC/D,SAAK,oBAAoB;AAAA,EAC3B;AAAA;AAAA;AAAA;AAAA,EAKA,iBAAiB,UAA4B;AAC3C,WAAO,KAAK,aAAa,kBAAkB,QAAQ;AAAA,EACrD;AAAA;AAAA;AAAA;AAAA,EAKQ,iBAAsC;AAC5C,UAAM,UAAU,oBAAI,IAAoB;AAGxC,UAAM,iBAAiB;AAAA,MACrB,EAAE,SAAS,eAAe,UAAU,YAAY;AAAA,MAChD,EAAE,SAAS,WAAW,UAAU,QAAQ;AAAA,MACxC,EAAE,SAAS,aAAa,UAAU,UAAU;AAAA,MAC5C,EAAE,SAAS,WAAW,UAAU,QAAQ;AAAA,MACxC,EAAE,SAAS,eAAe,UAAU,YAAY;AAAA,MAChD,EAAE,SAAS,YAAY,UAAU,UAAU;AAAA,MAC3C,EAAE,SAAS,YAAY,UAAU,SAAS;AAAA,MAC1C,EAAE,SAAS,aAAa,UAAU,UAAU;AAAA,MAC5C,EAAE,SAAS,UAAU,UAAU,OAAO;AAAA,MACtC,EAAE,SAAS,eAAe,UAAU,YAAY;AAAA,MAChD,EAAE,SAAS,gBAAgB,UAAU,aAAa;AAAA,MAClD,EAAE,SAAS,cAAc,UAAU,WAAW;AAAA,MAC9C,EAAE,SAAS,kBAAkB,UAAU,eAAe;AAAA,MACtD,EAAE,SAAS,eAAe,UAAU,YAAY;AAAA,MAChD,EAAE,SAAS,oBAAoB,UAAU,iBAAiB;AAAA,MAC1D,EAAE,SAAS,gBAAgB,UAAU,aAAa;AAAA,MAClD,EAAE,SAAS,iBAAiB,UAAU,cAAc;AAAA,MACpD,EAAE,SAAS,qBAAqB,UAAU,kBAAkB;AAAA,MAC5D,EAAE,SAAS,gBAAgB,UAAU,aAAa;AAAA,MAClD,EAAE,SAAS,aAAa,UAAU,UAAU;AAAA,MAC5C,EAAE,SAAS,SAAS,UAAU,MAAM;AAAA,IACtC;AAEA,eAAW,YAAY,KAAK,aAAa,cAAc,GAAG;AACxD,iBAAW,EAAE,SAAS,SAAS,KAAK,gBAAgB;AAClD,YAAI,QAAQ,KAAK,QAAQ,GAAG;AAC1B,kBAAQ,IAAI,UAAU,QAAQ;AAC9B;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKQ,iBACN,kBACA,cACA,cACS;AACT,QAAI,aAAc,QAAO;AACzB,QAAI,CAAC,kBAAkB,OAAQ,QAAO;AAEtC,WAAO,iBAAiB,MAAM,CAAC,aAAa;AAE1C,UAAI,aAAa,SAAS,QAAQ,EAAG,QAAO;AAE5C,UAAI,aAAa,SAAS,GAAG,EAAG,QAAO;AAGvC,aAAO,aAAa,KAAK,CAAC,YAAY;AACpC,YAAI,QAAQ,SAAS,IAAI,GAAG;AAC1B,gBAAM,SAAS,QAAQ,MAAM,GAAG,EAAE;AAClC,iBAAO,SAAS,WAAW,SAAS,GAAG;AAAA,QACzC;AACA,eAAO;AAAA,MACT,CAAC;AAAA,IACH,CAAC;AAAA,EACH;AACF;",
+  "names": ["status"]
+}

package/dist/modules/ai_assistant/lib/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=types.js.map

package/dist/modules/ai_assistant/lib/types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}