luca 3.0.0 → 3.1.0

package/src/introspection/scan.ts

@@ -135,9 +135,10 @@ export class IntrospectionScannerFeature extends Feature<IntrospectionScannerSta
     }
 
     const pattern = path.join(srcPath, '**/*.ts');
-    return await glob(pattern, {
+    const files = await glob(pattern, {
       ignore: ['**/*.d.ts', '**/node_modules/**']
     });
+    return files.sort();
   }
 
   private async analyzeFile(filePath: string): Promise<{ helpers: HelperIntrospection[], containers: Partial<ContainerIntrospection>[] }> {
@@ -1099,23 +1100,27 @@ export class IntrospectionScannerFeature extends Feature<IntrospectionScannerSta
     }
     imports += ` } from '${importSource}';\n\n`;
 
-    const registrations = results.map(result => {
+    // Sort by id/className for deterministic output across runs
+    const sortedResults = [...results].sort((a, b) => a.id.localeCompare(b.id));
+    const sortedContainers = [...containerResults].sort((a, b) => (a.className || '').localeCompare(b.className || ''));
+
+    const registrations = sortedResults.map(result => {
       const data = JSON.stringify(result, null, 2);
       return `setBuildTimeData('${result.id}', ${data});`;
     }).join('\n\n');
 
     let containerRegistrations = '';
     if (hasContainers) {
-      containerRegistrations = '\n\n// Container introspection data\n' + containerResults.map(result => {
+      containerRegistrations = '\n\n// Container introspection data\n' + sortedContainers.map(result => {
         const data = JSON.stringify(result, null, 2);
         return `setContainerBuildTimeData('${result.className}', ${data});`;
       }).join('\n\n');
     }
 
-    const exportStatement = `\nexport const introspectionData = ${JSON.stringify(results, null, 2)};\n`;
-    const containerExport = hasContainers ? `\nexport const containerIntrospectionData = ${JSON.stringify(containerResults, null, 2)};\n` : '';
+    const exportStatement = `\nexport const introspectionData = ${JSON.stringify(sortedResults, null, 2)};\n`;
+    const containerExport = hasContainers ? `\nexport const containerIntrospectionData = ${JSON.stringify(sortedContainers, null, 2)};\n` : '';
 
-    return `${imports}// Auto-generated introspection registry data\n// Generated at: ${new Date().toISOString()}\n\n${registrations}${containerRegistrations}${exportStatement}${containerExport}`;
+    return `${imports}// Auto-generated introspection registry data\n\n${registrations}${containerRegistrations}${exportStatement}${containerExport}`;
   }
 }
 

package/src/node/container.ts

@@ -64,6 +64,8 @@ import "./features/container-link";
 import "./features/semantic-search";
 import "./features/dns";
 import "./features/redis";
+import "./features/socket-repl";
+import "./features/telnyx-assistant-connector";
 
 import type { ChildProcess } from "./features/proc";
 import type { DiskCache } from "./features/disk-cache";
@@ -108,6 +110,8 @@ import type { ContainerLink } from './features/container-link';
 import type { SemanticSearch } from './features/semantic-search';
 import type { Dns } from './features/dns';
 import type { Redis } from './features/redis';
+import type { SocketRepl } from './features/socket-repl';
+import type { TelnyxAssistantConnector } from './features/telnyx-assistant-connector';
 export { State };
 
 export {
@@ -147,6 +151,8 @@ export {
   type SemanticSearch,
   type Dns,
   type Redis,
+  type SocketRepl,
+  type TelnyxAssistantConnector,
   type Transpiler,
 };
 
@@ -213,6 +219,8 @@ export interface NodeFeatures extends AvailableFeatures {
   semanticSearch: typeof SemanticSearch;
   dns: typeof Dns;
   redis: typeof Redis;
+  socketRepl: typeof SocketRepl;
+  telnyxAssistantConnector: typeof TelnyxAssistantConnector;
 }
 
 export type ClientsAndServersInterface = ClientsInterface & ServersInterface & CommandsInterface & EndpointsInterface & SelectorsInterface;
@@ -240,7 +248,7 @@ export interface NodeContainerState extends ContainerState {
  *
  * @example
  * ```ts
- * import container from '@soederpop/luca/node'
+ * import container from 'luca/node'
  *
  * // File operations
  * const content = container.fs.readFile('README.md')

package/src/node/features/content-db.ts

@@ -1,6 +1,6 @@
 import { Feature } from '../feature.js'
 import * as contentbaseExports from 'contentbase'
-import { parse, Collection, extractSections, type ModelDefinition } from 'contentbase'
+import { parse, Collection, Document, extractSections, type ModelDefinition } from 'contentbase'
 import { z } from 'zod'
 import { FeatureStateSchema, FeatureOptionsSchema, FeatureEventsSchema } from '../../schemas/base.js'
 import { realpathSync } from 'node:fs'
@@ -184,7 +184,7 @@ export class ContentDb extends Feature<ContentDbState, ContentDbOptions> {
 
     const vm = this.container.feature('vm') as any
 
-    // Seed luca modules first (helpers does this for @soederpop/luca)
+    // Seed luca modules first (helpers does this for luca)
     const helpers = this.container.feature('helpers') as any
     if (helpers?.seedVirtualModules) {
       helpers.seedVirtualModules()
@@ -300,6 +300,43 @@ export class ContentDb extends Feature<ContentDbState, ContentDbOptions> {
     return parse(path)
   }
 
+  /**
+   * Get a document object by collection ID, file path, or inline markdown string.
+   * Exactly one of `id`, `path`, or `content` must be provided.
+   *
+   * @param options.id - Collection document ID (e.g. `'guides/intro'`); auto-loads the collection if needed
+   * @param options.path - Absolute or relative path to a markdown file on disk
+   * @param options.content - Raw markdown string; returned as an in-memory Document
+   * @returns The Document instance
+   * @example
+   * ```typescript
+   * // By collection document ID
+   * const doc = await contentDb.document({ id: 'guides/intro' })
+   *
+   * // By file path
+   * const doc = await contentDb.document({ path: '/absolute/path/to/file.md' })
+   *
+   * // In-memory from a markdown string
+   * const doc = contentDb.document({ content: '# Hello\n\nworld' })
+   * ```
+   */
+  async document(options: { id: string; path?: never; content?: never } | { path: string; id?: never; content?: never } | { content: string; id?: never; path?: never }): Promise<Document> {
+    if ('content' in options && options.content != null) {
+      return new Document({ content: options.content, path: '/virtual/document.md' })
+    }
+
+    if ('path' in options && options.path != null) {
+      return parse(options.path) as unknown as Document
+    }
+
+    if ('id' in options && options.id != null) {
+      if (!this.isLoaded) await this.load()
+      return this.collection.document(options.id) as unknown as Document
+    }
+
+    throw new Error('document() requires exactly one of: id, path, or content')
+  }
+
   /**
    * Load the collection, discovering models from models.ts and parsing all documents.
    *

package/src/node/features/display-result.ts

@@ -0,0 +1,57 @@
+import { inspect } from 'util'
+
+const BUILTIN_TYPES = new Set(['Object', 'Array', 'Map', 'Set', 'Date', 'RegExp', 'Promise', 'Error', 'Number', 'String', 'Boolean'])
+
+export function displayResult(value: any) {
+	if (typeof value !== 'object' || value === null) {
+		console.log(value)
+		return
+	}
+
+	const hasCustomInspect = typeof value[Symbol.for('nodejs.util.inspect.custom')] === 'function'
+	const ctorName = value.constructor?.name
+	const isClassInstance = ctorName && !BUILTIN_TYPES.has(ctorName)
+
+	// Objects with custom inspect or builtins: use standard inspect
+	if (hasCustomInspect || !isClassInstance) {
+		console.log(inspect(value, { colors: true, depth: 4 }))
+		return
+	}
+
+	// Class instances: show clean data (no _ props, no functions)
+	const data: Record<string, any> = {}
+	for (const [k, v] of Object.entries(value)) {
+		if (k.startsWith('_') || typeof v === 'function') continue
+		data[k] = v
+	}
+	const body = inspect(data, { colors: true, depth: 3 })
+	console.log(`${ctorName} ${body}`)
+
+	// Collect methods and getters from own + prototype chain
+	const methods: string[] = []
+	const getters: string[] = []
+
+	for (const [k, v] of Object.entries(value)) {
+		if (k.startsWith('_')) continue
+		if (typeof v === 'function') methods.push(k)
+	}
+
+	let proto = Object.getPrototypeOf(value)
+	while (proto && proto !== Object.prototype) {
+		for (const k of Object.getOwnPropertyNames(proto)) {
+			if (k === 'constructor' || k.startsWith('_')) continue
+			const desc = Object.getOwnPropertyDescriptor(proto, k)
+			if (!desc) continue
+			if (desc.get && !getters.includes(k)) getters.push(k)
+			else if (typeof desc.value === 'function' && !methods.includes(k)) methods.push(k)
+		}
+		proto = Object.getPrototypeOf(proto)
+	}
+
+	if (getters.length || methods.length) {
+		const parts: string[] = []
+		if (getters.length) parts.push(`  \x1b[36mgetters:\x1b[0m ${getters.sort().join(', ')}`)
+		if (methods.length) parts.push(`  \x1b[36mmethods:\x1b[0m ${methods.sort().map(m => m + '()').join(', ')}`)
+		console.log(parts.join('\n'))
+	}
+}

package/src/node/features/helpers.ts

@@ -3,6 +3,8 @@ import { FeatureStateSchema, FeatureOptionsSchema, FeatureEventsSchema } from '.
 import { Feature } from '../feature.js'
 import { Feature as UniversalFeature } from '../../feature.js'
 import { Client, clients } from '../../client.js'
+import { allHelperInstances } from '../../container.js'
+import type { Helper } from '../../helper.js'
 import { RestClient } from '../../clients/rest.js'
 import { GraphClient } from '../../clients/graph.js'
 import { WebSocketClient } from '../../clients/websocket.js'
@@ -108,14 +110,14 @@ export class Helpers extends Feature<HelpersState, HelpersOptions> {
 
   /**
    * Whether to use native `import()` for loading project helpers.
-   * True only if `@soederpop/luca` is actually resolvable in `node_modules`.
+   * True only if `luca` is actually resolvable in `node_modules`.
    * Warns when `node_modules` exists but the package is missing.
    */
   get useNativeImport(): boolean {
     const hasNodeModules = existsSync(resolve(this.rootDir, 'node_modules'))
     const hasLuca = hasNodeModules && existsSync(resolve(this.rootDir, 'node_modules', '@soederpop', 'luca'))
 
-    // VM bundling handles missing @soederpop/luca gracefully — no warning needed
+    // VM bundling handles missing luca gracefully — no warning needed
 
     return hasLuca
   }
@@ -126,7 +128,7 @@ export class Helpers extends Feature<HelpersState, HelpersOptions> {
 
   /**
    * Seeds the VM feature with virtual modules so that project-level files
-   * can `import` / `require('@soederpop/luca')`, `zod`, etc. without
+   * can `import` / `require('luca')`, `zod`, etc. without
    * needing them in `node_modules`.
    *
    * Called automatically when `useNativeImport` is false.
@@ -138,7 +140,7 @@ export class Helpers extends Feature<HelpersState, HelpersOptions> {
 
     const vm = this.container.feature('vm') as unknown as VM
 
-    // Provide the full @soederpop/luca barrel — everything node.ts exports
+    // Provide the full luca barrel — everything node.ts exports
     // We build the exports object from the already-loaded modules in memory
     const lucaExports: Record<string, any> = {
       // Core classes
@@ -208,11 +210,23 @@ export class Helpers extends Feature<HelpersState, HelpersOptions> {
       schemasModule.FeatureEventsSchema = FeatureEventsSchema
     }
 
+    vm.defineModule('luca', lucaExports)
+    vm.defineModule('luca/schemas', schemasModule)
+    vm.defineModule('luca/node', lucaExports)
+
+    // Deep import paths AIs and developers might reach for
+    vm.defineModule('luca/client', { Client, ClientsRegistry: clients.constructor, default: Client })
+    vm.defineModule('luca/server', { Server, ServersRegistry: servers.constructor, default: Server })
+    vm.defineModule('luca/clients/rest', { RestClient, default: RestClient })
+    vm.defineModule('luca/clients/graph', { GraphClient, default: GraphClient })
+    vm.defineModule('luca/clients/websocket', { WebSocketClient, default: WebSocketClient })
+    vm.defineModule('luca/servers/express', { ExpressServer, default: ExpressServer })
+    vm.defineModule('luca/servers/socket', { WebsocketServer, default: WebsocketServer })
+
+    // Legacy package name aliases for backwards compatibility
     vm.defineModule('@soederpop/luca', lucaExports)
     vm.defineModule('@soederpop/luca/schemas', schemasModule)
     vm.defineModule('@soederpop/luca/node', lucaExports)
-
-    // Deep import paths AIs and developers might reach for
     vm.defineModule('@soederpop/luca/client', { Client, ClientsRegistry: clients.constructor, default: Client })
     vm.defineModule('@soederpop/luca/server', { Server, ServersRegistry: servers.constructor, default: Server })
     vm.defineModule('@soederpop/luca/clients/rest', { RestClient, default: RestClient })
@@ -224,6 +238,26 @@ export class Helpers extends Feature<HelpersState, HelpersOptions> {
     vm.defineModule('zod', { z, default: { z } })
   }
 
+  /**
+   * Returns all instantiated helper instances across all types, optionally filtered by class.
+   *
+   * @param FilterClass - When provided, only instances of this class are returned.
+   *
+   * @example
+   * ```typescript
+   * // All instances of any type
+   * container.helpers.getInstances()
+   *
+   * // All Assistant instances
+   * const assistants = container.helpers.getInstances(Assistant)
+   * ```
+   */
+  getInstances(): Helper[]
+  getInstances<T extends Helper>(FilterClass: new (...args: any[]) => T): T[]
+  getInstances<T extends Helper>(FilterClass?: new (...args: any[]) => T): Helper[] | T[] {
+    return FilterClass ? allHelperInstances(FilterClass) : allHelperInstances()
+  }
+
   /**
    * Returns a unified view of all available helpers across all registries.
    * Each key is a registry type, each value is the list of helper names in that registry.
@@ -458,7 +492,11 @@ export class Helpers extends Feature<HelpersState, HelpersOptions> {
     try {
       const fm = await this.ensureFileManager()
       const absPatterns = [`${dir}/*.ts`, `${dir}/**/*.ts`]
-      const relPatterns = [`${type}/*.ts`, `${type}/**/*.ts`]
+      // Only use relative patterns when rootDir matches the container cwd,
+      // otherwise the fileManager (rooted in cwd) returns files from the
+      // wrong project which then get resolved against this.rootDir.
+      const useRelative = this.rootDir === this.container.cwd
+      const relPatterns = useRelative ? [`${type}/*.ts`, `${type}/**/*.ts`] : []
       const matched = fm.match([...absPatterns, ...relPatterns])
       files = matched.map((f: string) => f.startsWith('/') ? f : resolve(this.rootDir, f))
     } catch {}
@@ -608,6 +646,7 @@ export class Helpers extends Feature<HelpersState, HelpersOptions> {
           const Grafted = graftModule(Command as any, {
             description: commandModule.description,
             argsSchema: commandModule.argsSchema,
+            positionals: commandModule.positionals ?? mod.positionals,
             handler: commandModule.handler,
           }, name, 'commands')
           commands.register(name, Grafted as any)

package/src/node/features/python.ts

@@ -1,8 +1,6 @@
 import { z } from 'zod'
 import { FeatureStateSchema, FeatureOptionsSchema, FeatureEventsSchema } from '../../schemas/base.js'
 import { Feature } from "../feature.js";
-import { existsSync } from 'fs';
-import { join, resolve } from 'path';
 import { tmpdir } from 'os';
 import { bridgeScript } from '../../python/generated.js';
 import type { ChildProcess } from 'child_process';
@@ -161,7 +159,7 @@ export class Python<
     
     // Setup project directory
     if (this.options.dir) {
-      this.state.set('projectDir', resolve(this.options.dir))
+      this.state.set('projectDir', this.container.paths.resolve(this.options.dir))
     } else {
       this.state.set('projectDir', this.container.cwd)
     }
@@ -170,7 +168,7 @@ export class Python<
     await this.detectEnvironment()
     
     // Execute context script if provided
-    if (this.options.contextScript && existsSync(this.options.contextScript)) {
+    if (this.options.contextScript && this.container.feature('fs').exists(this.options.contextScript)) {
       await this.execute(`exec(open('${this.options.contextScript}').read())`)
     }
 
@@ -217,6 +215,8 @@ export class Python<
     let environmentType: PythonState['environmentType'] = null
 
     const proc = this.container.feature('proc')
+    const fs = this.container.feature('fs')
+    const paths = this.container.paths
 
     /** Resolve a binary to its full path via `which`, falling back to the bare name. */
     const resolveBin = (name: string): string => {
@@ -228,12 +228,14 @@ export class Python<
       pythonPath = this.options.pythonPath
       environmentType = 'system'
     }
-    // Check for uv
-    else if (existsSync(join(projectDir, 'uv.lock')) || existsSync(join(projectDir, 'pyproject.toml'))) {
+
+    // Check for uv — independent so a missing uv binary falls through to conda/venv
+    if (!pythonPath && (fs.exists(paths.resolve(projectDir, 'uv.lock')) || fs.exists(paths.resolve(projectDir, 'pyproject.toml')))) {
       try {
         const uvBin = resolveBin('uv')
         const result = await proc.execAndCapture(`${uvBin} run python --version`)
-        if (result.exitCode === 0) {
+        // execAndCapture returns exitCode 0 on ENOENT — check result.error to confirm the binary actually ran
+        if (result.exitCode === 0 && !result.error) {
           pythonPath = `${uvBin} run python`
           environmentType = 'uv'
         }
@@ -241,12 +243,13 @@ export class Python<
         // Fall through to next detection method
       }
     }
+
     // Check for conda
-    else if (existsSync(join(projectDir, 'environment.yml')) || existsSync(join(projectDir, 'conda.yml'))) {
+    if (!pythonPath && (fs.exists(paths.resolve(projectDir, 'environment.yml')) || fs.exists(paths.resolve(projectDir, 'conda.yml')))) {
       try {
         const condaBin = resolveBin('conda')
         const result = await proc.execAndCapture(`${condaBin} run python --version`)
-        if (result.exitCode === 0) {
+        if (result.exitCode === 0 && !result.error) {
           pythonPath = `${condaBin} run python`
           environmentType = 'conda'
         }
@@ -254,14 +257,15 @@ export class Python<
         // Fall through to next detection method
       }
     }
+
     // Check for venv
-    else if (existsSync(join(projectDir, 'venv')) || existsSync(join(projectDir, '.venv'))) {
-      const venvPath = existsSync(join(projectDir, 'venv')) ? 'venv' : '.venv'
+    if (!pythonPath && (fs.exists(paths.resolve(projectDir, 'venv')) || fs.exists(paths.resolve(projectDir, '.venv')))) {
+      const venvPath = fs.exists(paths.resolve(projectDir, 'venv')) ? 'venv' : '.venv'
       const venvPython = process.platform === 'win32'
-        ? join(projectDir, venvPath, 'Scripts', 'python.exe')
-        : join(projectDir, venvPath, 'bin', 'python')
+        ? paths.resolve(projectDir, venvPath, 'Scripts', 'python.exe')
+        : paths.resolve(projectDir, venvPath, 'bin', 'python')
 
-      if (existsSync(venvPython)) {
+      if (fs.exists(venvPython)) {
         pythonPath = venvPython
         environmentType = 'venv'
       }
@@ -317,6 +321,8 @@ export class Python<
    */
   async installDependencies(): Promise<{ stdout: string; stderr: string; exitCode: number }> {
     const proc = this.container.feature('proc')
+    const fs = this.container.feature('fs')
+    const paths = this.container.paths
     const projectDir = this.state.get('projectDir')!
     const environmentType = this.state.get('environmentType')
 
@@ -330,9 +336,9 @@ export class Python<
           installCommand = 'uv sync'
           break
         case 'conda':
-          if (existsSync(join(projectDir, 'environment.yml'))) {
+          if (fs.exists(paths.resolve(projectDir, 'environment.yml'))) {
             installCommand = 'conda env update -f environment.yml'
-          } else if (existsSync(join(projectDir, 'conda.yml'))) {
+          } else if (fs.exists(paths.resolve(projectDir, 'conda.yml'))) {
             installCommand = 'conda env update -f conda.yml'
           } else {
             installCommand = 'conda install --file requirements.txt'
@@ -341,10 +347,10 @@ export class Python<
         case 'venv':
         case 'system':
         default:
-          if (existsSync(join(projectDir, 'requirements.txt'))) {
+          if (fs.exists(paths.resolve(projectDir, 'requirements.txt'))) {
             const pythonPath = this.state.get('pythonPath')!
             installCommand = `${pythonPath} -m pip install -r requirements.txt`
-          } else if (existsSync(join(projectDir, 'pyproject.toml'))) {
+          } else if (fs.exists(paths.resolve(projectDir, 'pyproject.toml'))) {
             const pythonPath = this.state.get('pythonPath')!
             installCommand = `${pythonPath} -m pip install -e .`
           } else {
@@ -406,7 +412,7 @@ export class Python<
     // Create temporary script in system temp dir (not inside the project)
     const tempDir = `${tmpdir()}/luca-python-temp`
     await fs.ensureFolder(tempDir)
-    const scriptPath = join(tempDir, `script-${Date.now()}.py`)
+    const scriptPath = this.container.paths.resolve(tempDir, `script-${Date.now()}.py`)
     
     // Build the Python script
     let script = ''

package/src/node/features/repl.ts

@@ -3,7 +3,7 @@ import { FeatureStateSchema, FeatureOptionsSchema } from '../../schemas/base.js'
 import { Feature } from "../feature.js";
 import vm from 'vm'
 import readline from 'readline'
-import { displayResult } from '../../commands/eval.js'
+import { displayResult } from './display-result.js'
 
 export const ReplStateSchema = FeatureStateSchema.extend({
   started: z.boolean().optional().describe('Whether the REPL server has been started'),

package/src/node/features/secure-shell.ts

@@ -109,8 +109,8 @@ export class SecureShell extends Feature<SecureShellState, SecureShellOptions> {
 			sshCmd += ` -i "${key}"`
 		}
 		
-		// Disable host key checking for automation (optional - you may want to remove this for security)
-		sshCmd += ` -o StrictHostKeyChecking=no`
+		// Batch mode fails immediately instead of hanging on interactive prompts
+		sshCmd += ` -o BatchMode=yes -o StrictHostKeyChecking=no`
 		
 		sshCmd += ` ${username}@${host}`
 		
@@ -129,8 +129,8 @@ export class SecureShell extends Feature<SecureShellState, SecureShellOptions> {
 			scpCmd += ` -i "${key}"`
 		}
 		
-		// Disable host key checking for automation
-		scpCmd += ` -o StrictHostKeyChecking=no`
+		// Batch mode fails immediately instead of hanging on interactive prompts
+		scpCmd += ` -o BatchMode=yes -o StrictHostKeyChecking=no`
 		
 		return scpCmd
 	}
@@ -150,18 +150,12 @@ export class SecureShell extends Feature<SecureShellState, SecureShellOptions> {
 	 * ```
 	 */
 	async testConnection(): Promise<boolean> {
-		try {
-			const testCmd = `${this.buildSSHConnectionString()} "echo 'connection_test'"`
-			const result = await this.proc.execAndCapture(testCmd)
-			
-			if (result.exitCode === 0 && result.stdout.trim() === 'connection_test') {
-				this.setState({ connected: true })
-				return true
-			} else {
-				this.setState({ connected: false })
-				return false
-			}
-		} catch (error) {
+		const result = await this.exec(`echo 'connected'`).catch(e => '')
+
+		if (String(result).trim() === 'connected') {
+			this.setState({ connected: true })
+			return true
+		} else {
 			this.setState({ connected: false })
 			return false
 		}
@@ -264,4 +258,4 @@ export class SecureShell extends Feature<SecureShellState, SecureShellOptions> {
 	}
 }
 
-export default SecureShell
+export default SecureShell

package/src/node/features/semantic-search.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod'
 import { FeatureStateSchema, FeatureOptionsSchema, FeatureEventsSchema } from '../../schemas/base.js'
-import { type AvailableFeatures } from '@soederpop/luca/feature'
+import { type AvailableFeatures } from 'luca/feature'
 import { Feature } from '../feature.js'
 import { Database } from 'bun:sqlite'
 import { createHash } from 'node:crypto'
@@ -8,7 +8,7 @@ import { mkdirSync, existsSync, statSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 import { homedir } from 'node:os'
 
-declare module '@soederpop/luca/feature' {
+declare module 'luca/feature' {
 	interface AvailableFeatures {
 		semanticSearch: typeof SemanticSearch
 	}