js-agent-core 1.0.1

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "js-agent-core",
+  "version": "1.0.1",
+  "description": "A powerful, isomorphic JS Agent core library for building AI agents with TypeScript",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "src"
+  ],
+  "scripts": {
+    "build": "npm run test:all && tsc",
+    "test": "vitest run tests/unit",
+    "test:unit": "vitest run tests/unit",
+    "test:integration": "vitest run tests/integration",
+    "test:all": "npm run test:unit && npm run test:integration",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "bundle": "node scripts/bundle.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@gitee.com:lin_zhi_xiong/js-agent.git"
+  },
+  "keywords": [
+    "agent",
+    "llm",
+    "ai",
+    "typescript"
+  ],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "zod": "^3.25.76",
+    "zod-to-json-schema": "^3.25.1"
+  },
+  "devDependencies": {
+    "@types/node": "^18.19.1",
+    "@vitest/coverage-v8": "^3.0.5",
+    "jsdom": "^24.1.1",
+    "typescript": "^5.9.3",
+    "vitest": "^3.0.5"
+  }
+}

package/src/core/AgentDashboard.ts

@@ -0,0 +1,533 @@
+import { BaseAgent } from './BaseAgent.js';
+
+export interface DashboardOptions {
+  container?: HTMLElement;
+  autoOpen?: boolean;
+}
+
+export class AgentDashboard {
+  private agent: BaseAgent;
+  private container: HTMLElement;
+  private isVisible: boolean = false;
+
+  constructor(agent: BaseAgent, options: DashboardOptions = {}) {
+    this.agent = agent;
+    this.container = options.container || this.createDefaultContainer();
+    this.isVisible = options.autoOpen || false;
+    
+    if (this.isVisible) {
+      this.show();
+    }
+    
+    this.initUI();
+    this.bindEvents();
+  }
+
+  private createDefaultContainer(): HTMLElement {
+    const div = document.createElement('div');
+    div.id = 'agent-dashboard';
+    div.style.cssText = `
+      width: 350px;
+      height: 100vh;
+      background-color: #1e1e1e;
+      color: #d4d4d4;
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+      box-shadow: -2px 0 10px rgba(0,0,0,0.5);
+      display: none;
+      flex-direction: column;
+      z-index: 9999;
+      overflow: hidden;
+    `;
+
+    // Try to find a specific container for the dashboard, otherwise append to body
+    const wrapper = document.getElementById('dashboard-wrapper');
+    if (wrapper) {
+      div.style.width = '100%';
+      div.style.height = '100%';
+      div.style.boxShadow = 'none';
+      div.style.display = 'flex'; // Always show when embedded
+      wrapper.appendChild(div);
+    } else if (document.body) {
+      div.style.position = 'fixed';
+      div.style.bottom = '0';
+      div.style.right = '0';
+      document.body.appendChild(div);
+    } else if (document.readyState === 'loading') {
+      window.addEventListener('DOMContentLoaded', () => {
+        div.style.position = 'fixed';
+        div.style.bottom = '0';
+        div.style.right = '0';
+        document.body.appendChild(div);
+      });
+    } else {
+      // Should not happen in most browser environments but just in case
+      setTimeout(() => {
+        div.style.position = 'fixed';
+        div.style.bottom = '0';
+        div.style.right = '0';
+        document.body.appendChild(div);
+      }, 0);
+    }
+    return div;
+  }
+
+  private initUI(): void {
+    this.container.innerHTML = `
+      <div style="padding: 12px; background: #333; display: flex; justify-content: space-between; align-items: center; border-bottom: 1px solid #444;">
+        <span style="font-weight: bold; font-size: 14px;">JS-Agent Dashboard</span>
+        <button id="close-dashboard" style="background: transparent; border: none; color: #999; cursor: pointer; font-size: 18px;">&times;</button>
+      </div>
+      <div id="dashboard-content" style="flex: 1; overflow-y: auto; padding: 15px; font-size: 13px;">
+        <div id="status-indicator" style="margin-bottom: 15px; padding: 8px; border-radius: 4px; background: #252526; border-left: 4px solid #007acc;">
+          Status: <span id="agent-status">Ready</span>
+        </div>
+        <div id="log-container" style="margin-bottom: 15px;">
+           <div id="log-history" style="max-height: 150px; overflow-y: auto; margin-bottom: 10px; border-top: 1px solid #333; padding-top: 5px; display: none;"></div>
+        </div>
+        <div id="thought-log" style="margin-bottom: 15px;">
+          <div style="color: #569cd6; margin-bottom: 5px; font-weight: bold;">Thinking...</div>
+          <div id="thought-content" style="background: #252526; padding: 10px; border-radius: 4px; line-height: 1.5; min-height: 40px; border: 1px solid #333;"></div>
+        </div>
+        <div id="task-container" style="margin-bottom: 15px; position: relative;">
+           <div style="color: #ce9178; margin-bottom: 5px; font-weight: bold;">Task Graph</div>
+           <div id="task-graph-container" style="background: #252526; border-radius: 4px; border: 1px solid #333; height: 200px; position: relative; overflow: auto; margin-bottom: 10px;">
+             <svg id="task-graph-svg" style="position: absolute; top: 0; left: 0; width: 100%; height: 100%; pointer-events: none;"></svg>
+             <div id="task-list" style="position: relative; width: 100%; height: 100%;"></div>
+           </div>
+        </div>
+        <div id="memory-container" style="margin-bottom: 15px;">
+           <div style="color: #b5cea8; margin-bottom: 5px; font-weight: bold;">Memory Status</div>
+           <div id="memory-usage" style="background: #252526; padding: 10px; border-radius: 4px; border: 1px solid #333; font-size: 11px;">
+             <div style="display: flex; justify-content: space-between; margin-bottom: 5px;">
+               <span>Context Window (Tokens)</span>
+               <span id="token-usage">0 / 128k</span>
+             </div>
+             <div style="background: #1a1a1a; height: 6px; border-radius: 3px; overflow: hidden; margin-bottom: 10px;">
+               <div id="token-bar" style="width: 0%; height: 100%; background: #4caf50; transition: width 0.3s ease;"></div>
+             </div>
+             <div id="memory-logs" style="max-height: 100px; overflow-y: auto; color: #888;">
+               <div style="font-style: italic;">No memory entries yet...</div>
+             </div>
+           </div>
+        </div>
+      </div>
+    `;
+
+    this.container.querySelector('#close-dashboard')?.addEventListener('click', () => this.hide());
+  }
+
+  private bindEvents(): void {
+    this.agent.on('start', async (event) => {
+      const input = event.payload;
+      this.show();
+      this.updateStatus('Running');
+      this.clearThoughts();
+      this.clearTasks();
+      this.addLog('System', `Agent started with input: "${input}"`);
+      
+      // Sync memory state
+      const usage = await this.agent.getMemoryUsage();
+      this.updateMemoryUsage(usage.used, usage.total);
+      
+      const history = await this.agent.getHistory();
+      const logs = this.container.querySelector('#memory-logs') as HTMLElement;
+      if (logs) logs.innerHTML = '';
+      history.forEach(m => this.addMemoryEntry(m));
+    });
+
+    this.agent.on('think', (event) => {
+      const content = event.payload;
+      console.log('Dashboard: Think event received', content);
+      this.updateThought(content);
+    });
+
+    this.agent.on('task.plan', (event) => {
+      const plan = event.payload;
+      this.renderTasks(plan.tasks);
+      this.addLog('Planner', `New plan generated with ${plan.tasks.length} tasks.`);
+    });
+
+    this.agent.on('task.update', (event) => {
+      const task = event.payload;
+      this.updateTaskUI(task);
+      this.addLog('Task', `Task "${task.goal}" updated to ${task.status}`);
+    });
+
+    this.agent.on('tool.call', (event) => {
+      const payload = event.payload;
+      this.addLog('Tool', `Calling ${payload.name}...`);
+      this.highlightActiveTool(payload.name);
+    });
+
+    this.agent.on('tool.progress', (event) => {
+      const payload = event.payload;
+      this.updateToolProgress(payload.name, payload.percent, payload.message);
+    });
+
+    this.agent.on('tool.result', (event) => {
+      const result = event.payload;
+      const status = result.error ? 'failed' : 'success';
+      this.addLog('Tool', `Tool result: ${status}`);
+      // Find the tool name from the result if possible, or we might need to track current active tool
+      this.clearActiveToolHighlights();
+    });
+
+    this.agent.on('agent.done', (result) => {
+      console.log('Dashboard: Done event received', result);
+      this.updateStatus('Ready');
+      this.addLog('System', `Agent finished: ${result}`);
+    });
+
+    this.agent.on('agent.error', (error) => {
+      console.error('Dashboard: Error event received', error);
+      this.updateStatus('Error');
+      this.addLog('Error', error);
+    });
+
+    this.agent.on('memory.add', (payload) => {
+      this.addMemoryEntry(payload);
+    });
+
+    this.agent.on('memory.usage', (usage) => {
+      this.updateMemoryUsage(usage.used, usage.total);
+    });
+  }
+
+  private addMemoryEntry(payload: any): void {
+    const logs = this.container.querySelector('#memory-logs') as HTMLElement;
+    // Check if the first child is the "No memory entries yet" message
+    if (logs) {
+      if (logs.querySelector('div')?.style.fontStyle === 'italic') {
+        logs.innerHTML = '';
+      }
+      
+      const entry = document.createElement('div');
+      entry.style.cssText = 'border-bottom: 1px solid #333; padding: 6px; margin-bottom: 4px; background: #2d2d2d; border-radius: 4px;';
+      
+      const header = document.createElement('div');
+      header.style.cssText = 'display: flex; justify-content: space-between; margin-bottom: 4px; font-size: 11px;';
+      
+      const roleBadge = document.createElement('span');
+      roleBadge.className = 'role-badge';
+      const roleColors: Record<string, string> = {
+        'user': '#2196f3',
+        'assistant': '#4caf50',
+        'system': '#ff9800',
+        'tool': '#9c27b0'
+      };
+      const bg = roleColors[payload.role] || '#757575';
+      roleBadge.style.cssText = `background: ${bg}; color: white; padding: 2px 6px; border-radius: 10px; font-weight: bold;`;
+      roleBadge.textContent = payload.role.toUpperCase();
+      
+      const metaInfo = document.createElement('span');
+      metaInfo.style.color = '#888';
+      if (payload.name) {
+        metaInfo.textContent = payload.name;
+      }
+      
+      header.appendChild(roleBadge);
+      header.appendChild(metaInfo);
+      
+      const content = document.createElement('div');
+      content.style.cssText = 'font-size: 12px; color: #ccc; white-space: pre-wrap; word-break: break-word; max-height: 100px; overflow-y: auto;';
+      
+      // Simple truncation for very long content
+      const text = payload.content || '';
+      content.textContent = text.length > 500 ? text.substring(0, 500) + '...' : text;
+      
+      entry.appendChild(header);
+      entry.appendChild(content);
+      
+      logs.prepend(entry);
+    }
+  }
+
+  private updateMemoryUsage(used: number, total: number): void {
+    const usageText = this.container.querySelector('#token-usage') as HTMLElement;
+    const usageBar = this.container.querySelector('#token-bar') as HTMLElement;
+    if (usageText) {
+      const usedText = used < 1000 ? `${used}` : `${(used / 1000).toFixed(1)}k`;
+      const totalText = total < 1000 ? `${total}` : `${(total / 1000).toFixed(0)}k`;
+      usageText.textContent = `${usedText} / ${totalText}`;
+    }
+    if (usageBar) {
+      const percent = Math.min((used / total) * 100, 100);
+      usageBar.style.width = `${percent}%`;
+      usageBar.style.background = percent > 80 ? '#f44336' : (percent > 50 ? '#ff9800' : '#4caf50');
+    }
+  }
+
+  private updateTaskUI(task: any): void {
+    const taskEl = this.container.querySelector(`[data-task-id="${task.id}"]`) as HTMLElement;
+    if (taskEl) {
+      taskEl.style.borderLeftColor = this.getTaskStatusColor(task.status);
+    }
+  }
+
+  private addLog(label: string, message: string, color: string = '#888'): void {
+    const historyEl = this.container.querySelector('#log-history') as HTMLElement;
+    if (historyEl) {
+      historyEl.style.display = 'block';
+      const logEntry = document.createElement('div');
+      logEntry.className = 'log-entry';
+      logEntry.style.cssText = `margin-top: 5px; border-bottom: 1px solid #333; padding-bottom: 2px;`;
+      logEntry.innerHTML = `
+        <span style="color: ${this.getLabelColor(label)}; font-weight: bold; font-size: 11px;">[${label}]</span>
+        <span style="color: #ccc; font-size: 11px;">${message}</span>
+      `;
+      historyEl.appendChild(logEntry);
+      historyEl.scrollTop = historyEl.scrollHeight;
+    }
+  }
+
+  private getLabelColor(label: string): string {
+    switch (label) {
+      case 'System': return '#569cd6';
+      case 'Planner': return '#ce9178';
+      case 'Task': return '#b5cea8';
+      case 'Tool': return '#dcdcdc';
+      case 'Error': return '#f44336';
+      default: return '#888';
+    }
+  }
+
+  private updateStatus(status: string, color: string = '#007acc'): void {
+    const el = this.container.querySelector('#agent-status');
+    const indicator = this.container.querySelector('#status-indicator') as HTMLElement;
+    if (el) el.textContent = status;
+    if (indicator) indicator.style.borderLeftColor = color;
+  }
+
+  private highlightActiveTool(toolName: string): void {
+    const taskNodes = this.container.querySelectorAll('.task-node');
+    taskNodes.forEach(node => {
+      const toolText = (node as HTMLElement).querySelector('div:nth-child(2)')?.textContent;
+      if (toolText === toolName) {
+        (node as HTMLElement).style.boxShadow = '0 0 10px #2196f3';
+        (node as HTMLElement).style.borderColor = '#2196f3';
+        const progressContainer = (node as HTMLElement).querySelector('.progress-container') as HTMLElement;
+        if (progressContainer) progressContainer.style.display = 'block';
+      }
+    });
+  }
+
+  private updateToolProgress(toolName: string, percent: number, message?: string): void {
+    const taskNodes = this.container.querySelectorAll('.task-node');
+    taskNodes.forEach(node => {
+      const toolText = (node as HTMLElement).querySelector('div:nth-child(2)')?.textContent;
+      if (toolText === toolName) {
+        const progressBar = (node as HTMLElement).querySelector('.progress-bar') as HTMLElement;
+        if (progressBar) {
+          progressBar.style.width = `${percent}%`;
+        }
+        if (message) {
+          this.addLog('Tool', `${toolName}: ${message}`);
+        }
+      }
+    });
+  }
+
+  private clearActiveToolHighlights(): void {
+    const taskNodes = this.container.querySelectorAll('.task-node');
+    taskNodes.forEach(node => {
+      (node as HTMLElement).style.boxShadow = '0 2px 4px rgba(0,0,0,0.3)';
+      const taskId = (node as HTMLElement).getAttribute('data-task-id');
+      // Restore border color based on task status
+      const task = (this.agent as any).taskList?.tasks?.find((t: any) => t.id === taskId);
+      if (task) {
+        (node as HTMLElement).style.borderLeftColor = this.getTaskStatusColor(task.status);
+      }
+      const progressContainer = (node as HTMLElement).querySelector('.progress-container') as HTMLElement;
+      if (progressContainer) progressContainer.style.display = 'none';
+    });
+  }
+
+  private updateThought(content: string): void {
+    const el = this.container.querySelector('#thought-content');
+    if (el) {
+      // Append content to support history and multiple steps
+      const entry = document.createElement('div');
+      entry.style.cssText = 'border-bottom: 1px solid #333; padding: 5px 0;';
+      entry.textContent = content;
+      el.appendChild(entry);
+      
+      // Auto-scroll to bottom
+      const contentArea = this.container.querySelector('#dashboard-content');
+      if (contentArea) {
+        contentArea.scrollTop = contentArea.scrollHeight;
+      }
+    }
+  }
+
+  private clearThoughts(): void {
+    const el = this.container.querySelector('#thought-content');
+    if (el) el.textContent = '';
+  }
+
+  private renderTasks(tasks: any[]): void {
+    const list = this.container.querySelector('#task-list') as HTMLElement;
+    const svg = this.container.querySelector('#task-graph-svg') as unknown as SVGSVGElement;
+    if (!list || !svg) return;
+
+    list.innerHTML = '';
+    svg.innerHTML = '';
+
+    // Simple layout: arrange tasks in columns based on dependency level
+    const levels = this.calculateTaskLevels(tasks);
+    const maxLevel = Math.max(...Object.values(levels), 0);
+    const columnWidth = 150;
+    const rowHeight = 60;
+    const padding = 20;
+
+    // Set container size based on graph
+    const graphContainer = this.container.querySelector('#task-graph-container') as HTMLElement;
+    if (graphContainer) {
+      const width = (maxLevel + 1) * columnWidth + padding * 2;
+      const tasksPerLevel = Object.values(levels).reduce((acc: any, level) => {
+        acc[level] = (acc[level] || 0) + 1;
+        return acc;
+      }, {});
+      const maxTasksInLevel = Math.max(...Object.values(tasksPerLevel) as number[], 0);
+      const height = maxTasksInLevel * rowHeight + padding * 2;
+      
+      list.style.width = `${Math.max(width, graphContainer.clientWidth)}px`;
+      list.style.height = `${Math.max(height, 200)}px`;
+      svg.style.width = list.style.width;
+      svg.style.height = list.style.height;
+    }
+
+    const positions = new Map<string, { x: number, y: number }>();
+    const levelCounts = new Map<number, number>();
+
+    tasks.forEach(task => {
+      const level = levels[task.id] || 0;
+      const count = levelCounts.get(level) || 0;
+      
+      const x = padding + level * columnWidth;
+      const y = padding + count * rowHeight;
+      positions.set(task.id, { x, y });
+      levelCounts.set(level, count + 1);
+
+      const taskEl = document.createElement('div');
+      taskEl.className = 'task-node';
+      taskEl.setAttribute('data-task-id', task.id);
+      taskEl.style.cssText = `
+        position: absolute;
+        left: ${x}px;
+        top: ${y}px;
+        width: 120px;
+        padding: 8px;
+        background: #2d2d2d;
+        border-radius: 4px;
+        border-left: 3px solid ${this.getTaskStatusColor(task.status)};
+        font-size: 11px;
+        transition: all 0.3s ease;
+        z-index: 2;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.3);
+      `;
+      taskEl.innerHTML = `
+        <div style="font-weight: bold; white-space: nowrap; overflow: hidden; text-overflow: ellipsis;" title="${task.goal}">${task.goal}</div>
+        <div style="color: #888; font-size: 10px;">${task.tool || 'no tool'}</div>
+        <div class="progress-container" style="margin-top: 5px; background: #1a1a1a; height: 4px; border-radius: 2px; overflow: hidden; display: none;">
+          <div class="progress-bar" style="width: 0%; height: 100%; background: #2196f3; transition: width 0.3s ease;"></div>
+        </div>
+      `;
+      list.appendChild(taskEl);
+    });
+
+    // Draw dependency lines
+    tasks.forEach(task => {
+      if (task.dependsOn && Array.isArray(task.dependsOn)) {
+        task.dependsOn.forEach((depId: string) => {
+          const startPos = positions.get(depId);
+          const endPos = positions.get(task.id);
+          if (startPos && endPos) {
+            this.drawArrow(svg, startPos.x + 120, startPos.y + 20, endPos.x, endPos.y + 20);
+          }
+        });
+      }
+    });
+  }
+
+  private calculateTaskLevels(tasks: any[]): Record<string, number> {
+    const levels: Record<string, number> = {};
+    const taskMap = new Map(tasks.map(t => [t.id, t]));
+
+    const getLevel = (id: string, visited = new Set<string>()): number => {
+      if (levels[id] !== undefined) return levels[id];
+      if (visited.has(id)) return 0; // Circular dependency fallback
+      
+      visited.add(id);
+      const task = taskMap.get(id);
+      if (!task || !task.dependsOn || task.dependsOn.length === 0) {
+        levels[id] = 0;
+        return 0;
+      }
+
+      const depLevels = task.dependsOn.map((depId: string) => getLevel(depId, visited));
+      levels[id] = Math.max(...depLevels) + 1;
+      return levels[id];
+    };
+
+    tasks.forEach(t => getLevel(t.id));
+    return levels;
+  }
+
+  private drawArrow(svg: SVGSVGElement, x1: number, y1: number, x2: number, y2: number): void {
+    const path = document.createElementNS('http://www.w3.org/2000/svg', 'path');
+    const midX = (x1 + x2) / 2;
+    // Cubic bezier for smooth curves
+    const d = `M ${x1} ${y1} C ${midX} ${y1}, ${midX} ${y2}, ${x2} ${y2}`;
+    path.setAttribute('d', d);
+    path.setAttribute('stroke', '#555');
+    path.setAttribute('stroke-width', '1.5');
+    path.setAttribute('fill', 'none');
+    
+    // Arrow head
+    const markerId = 'arrowhead';
+    if (!svg.querySelector(`#${markerId}`)) {
+      const defs = document.createElementNS('http://www.w3.org/2000/svg', 'defs');
+      const marker = document.createElementNS('http://www.w3.org/2000/svg', 'marker');
+      marker.setAttribute('id', markerId);
+      marker.setAttribute('viewBox', '0 0 10 10');
+      marker.setAttribute('refX', '8');
+      marker.setAttribute('refY', '5');
+      marker.setAttribute('markerWidth', '6');
+      marker.setAttribute('markerHeight', '6');
+      marker.setAttribute('orient', 'auto-start-reverse');
+      const arrowPath = document.createElementNS('http://www.w3.org/2000/svg', 'path');
+      arrowPath.setAttribute('d', 'M 0 0 L 10 5 L 0 10 z');
+      arrowPath.setAttribute('fill', '#555');
+      marker.appendChild(arrowPath);
+      defs.appendChild(marker);
+      svg.appendChild(defs);
+    }
+    
+    path.setAttribute('marker-end', `url(#${markerId})`);
+    svg.appendChild(path);
+  }
+
+  private getTaskStatusColor(status: string): string {
+    switch (status) {
+      case 'completed': return '#4caf50';
+      case 'failed': return '#f44336';
+      case 'in_progress': return '#2196f3';
+      default: return '#666';
+    }
+  }
+
+  private clearTasks(): void {
+    const list = this.container.querySelector('#task-list');
+    if (list) list.innerHTML = '';
+  }
+
+  public show(): void {
+    this.container.style.display = 'flex';
+    this.isVisible = true;
+  }
+
+  public hide(): void {
+    this.container.style.display = 'none';
+    this.isVisible = false;
+  }
+}

package/src/core/AutoVectorStore.ts

@@ -0,0 +1,60 @@
+import { IVectorStore } from '../interfaces/index.js';
+import { MemoryVectorStore } from './MemoryVectorStore.js';
+
+/**
+ * A proxy that dynamically loads the appropriate VectorStore implementation
+ * based on the runtime environment (Node.js vs Browser).
+ */
+export class AutoVectorStore implements IVectorStore {
+  private instance: IVectorStore | null = null;
+  private options: any;
+
+  constructor(options: any = {}) {
+    this.options = options;
+  }
+
+  private async getInstance(): Promise<IVectorStore> {
+    if (this.instance) return this.instance;
+
+    const isNode = typeof process !== 'undefined' && process.versions?.node;
+    const isBrowser = typeof window !== 'undefined' && typeof indexedDB !== 'undefined';
+
+    try {
+      if (isNode) {
+        // Node.js: Dynamic import NodeFsVectorStore
+        const { NodeFsVectorStore } = await import('./persistence/NodeFsVectorStore.js');
+        this.instance = new NodeFsVectorStore(this.options);
+      } else if (isBrowser) {
+        // Browser: Use WebIndexedDbVectorStore (already exported from persistence/index.js)
+        const { WebIndexedDbVectorStore } = await import('./persistence/WebIndexedDbVectorStore.js');
+        this.instance = new WebIndexedDbVectorStore(this.options);
+      } else {
+        // Fallback: In-memory store
+        this.instance = new MemoryVectorStore();
+      }
+    } catch (error) {
+      console.warn('Failed to load environment-specific VectorStore, falling back to MemoryVectorStore', error);
+      this.instance = new MemoryVectorStore();
+    }
+
+    return this.instance!;
+  }
+
+  async add(text: string, embedding: number[], metadata?: Record<string, any>): Promise<void> {
+    const instance = await this.getInstance();
+    return instance.add(text, embedding, metadata);
+  }
+
+  async search(queryEmbedding: number[], topK?: number): Promise<Array<{ text: string; score: number; metadata?: Record<string, any> }>> {
+    const instance = await this.getInstance();
+    return instance.search(queryEmbedding, topK);
+  }
+
+  async searchByKeyword(keyword: string, topK?: number): Promise<Array<{ text: string; score: number; metadata?: Record<string, any> }>> {
+    const instance = await this.getInstance();
+    if (instance.searchByKeyword) {
+      return instance.searchByKeyword(keyword, topK);
+    }
+    return [];
+  }
+}