@multiplayer-app/ai-agent-node 0.0.1 → 0.1.0-beta.2

package/src/store/ModelStore.test.ts

@@ -1,473 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { ModelStore } from './ModelStore';
-import type { ModelOption } from '@multiplayer-app/ai-agent-types';
-
-describe('ModelStore', () => {
-  let modelStore: ModelStore;
-
-  // Helper to create mock models
-  const createMockModel = (
-    id: string,
-    label: string,
-    provider?: string,
-    options?: Partial<ModelOption>
-  ): ModelOption => ({
-    id,
-    label,
-    provider,
-    ...options
-  });
-
-  beforeEach(() => {
-    // Clear the singleton instance before each test
-    // We need to access the private instance property, so we'll clear via clear()
-    modelStore = ModelStore.getInstance();
-    modelStore.clear();
-  });
-
-  describe('getInstance', () => {
-    it('should return the same singleton instance on multiple calls', () => {
-      const instance1 = ModelStore.getInstance();
-      const instance2 = ModelStore.getInstance();
-      expect(instance1).toBe(instance2);
-    });
-
-    it('should return an instance of ModelStore', () => {
-      const instance = ModelStore.getInstance();
-      expect(instance).toBeInstanceOf(ModelStore);
-    });
-  });
-
-  describe('setModels', () => {
-    it('should set models in the store', () => {
-      const models: ModelOption[] = [
-        createMockModel('openai/gpt-4', 'GPT-4', 'openai'),
-        createMockModel('anthropic/claude-3', 'Claude 3', 'anthropic')
-      ];
-
-      modelStore.setModels(models);
-      expect(modelStore.getModels()).toEqual(models);
-    });
-
-    it('should update lastFetched timestamp when setting models', () => {
-      const models: ModelOption[] = [
-        createMockModel('openai/gpt-4', 'GPT-4', 'openai')
-      ];
-
-      const beforeSet = new Date();
-      modelStore.setModels(models);
-      const afterSet = new Date();
-      const lastFetched = modelStore.getLastFetched();
-
-      expect(lastFetched).not.toBeNull();
-      expect(lastFetched!.getTime()).toBeGreaterThanOrEqual(beforeSet.getTime());
-      expect(lastFetched!.getTime()).toBeLessThanOrEqual(afterSet.getTime());
-    });
-
-    it('should handle empty array', () => {
-      modelStore.setModels([]);
-      expect(modelStore.getModels()).toEqual([]);
-      expect(modelStore.hasModels()).toBe(false);
-    });
-
-    it('should replace existing models when called multiple times', () => {
-      const models1: ModelOption[] = [
-        createMockModel('openai/gpt-4', 'GPT-4', 'openai')
-      ];
-      const models2: ModelOption[] = [
-        createMockModel('anthropic/claude-3', 'Claude 3', 'anthropic'),
-        createMockModel('openai/gpt-3.5', 'GPT-3.5', 'openai')
-      ];
-
-      modelStore.setModels(models1);
-      expect(modelStore.getModels()).toHaveLength(1);
-
-      modelStore.setModels(models2);
-      expect(modelStore.getModels()).toHaveLength(2);
-      expect(modelStore.getModels()).toEqual(models2);
-    });
-  });
-
-  describe('getModels', () => {
-    it('should return empty array when no models are set', () => {
-      expect(modelStore.getModels()).toEqual([]);
-    });
-
-    it('should return all models that were set', () => {
-      const models: ModelOption[] = [
-        createMockModel('openai/gpt-4', 'GPT-4', 'openai'),
-        createMockModel('anthropic/claude-3', 'Claude 3', 'anthropic'),
-        createMockModel('google/gemini-pro', 'Gemini Pro', 'google')
-      ];
-
-      modelStore.setModels(models);
-      expect(modelStore.getModels()).toEqual(models);
-      expect(modelStore.getModels()).toHaveLength(3);
-    });
-
-    it('should return the same array reference (direct reference to internal array)', () => {
-      const models: ModelOption[] = [
-        createMockModel('openai/gpt-4', 'GPT-4', 'openai')
-      ];
-      modelStore.setModels(models);
-
-      const retrieved = modelStore.getModels();
-      // Note: getModels() returns the internal array directly, not a copy
-      expect(retrieved).toBe(modelStore.getModels()); // Same reference on multiple calls
-      expect(retrieved).toEqual(models); // Same content
-    });
-  });
-
-  describe('getModelsByProvider', () => {
-    beforeEach(() => {
-      modelStore.setModels([
-        createMockModel('openai/gpt-4', 'GPT-4', 'openai'),
-        createMockModel('openai/gpt-3.5', 'GPT-3.5', 'openai'),
-        createMockModel('anthropic/claude-3', 'Claude 3', 'anthropic'),
-        createMockModel('google/gemini-pro', 'Gemini Pro', 'google')
-      ]);
-    });
-
-    it('should return models for a specific provider', () => {
-      const openaiModels = modelStore.getModelsByProvider('openai');
-      expect(openaiModels).toHaveLength(2);
-      expect(openaiModels.every((m) => m.provider === 'openai')).toBe(true);
-    });
-
-    it('should return empty array for non-existent provider', () => {
-      const models = modelStore.getModelsByProvider('nonexistent');
-      expect(models).toEqual([]);
-    });
-
-    it('should return empty array for provider with no models', () => {
-      const models = modelStore.getModelsByProvider('azure');
-      expect(models).toEqual([]);
-    });
-
-    it('should handle case-sensitive provider names', () => {
-      const models = modelStore.getModelsByProvider('OpenAI');
-      expect(models).toEqual([]); // Should be case-sensitive
-    });
-
-    it('should return models without provider when filtering for empty string', () => {
-      modelStore.setModels([
-        createMockModel('model-1', 'Model 1'), // No provider
-        createMockModel('openai/gpt-4', 'GPT-4', 'openai')
-      ]);
-
-      const modelsWithoutProvider = modelStore.getModelsByProvider('');
-      expect(modelsWithoutProvider).toHaveLength(0); // Empty string won't match undefined
-    });
-  });
-
-  describe('getModelById', () => {
-    beforeEach(() => {
-      modelStore.setModels([
-        createMockModel('openai/gpt-4', 'GPT-4', 'openai'),
-        createMockModel('anthropic/claude-3-opus', 'Claude 3 Opus', 'anthropic'),
-        createMockModel('google/gemini-pro', 'Gemini Pro', 'google'),
-        createMockModel('simple-model', 'Simple Model', 'custom')
-      ]);
-    });
-
-    it('should return model when exact ID matches', () => {
-      const model = modelStore.getModelById('openai/gpt-4');
-      expect(model).toBeDefined();
-      expect(model?.id).toBe('openai/gpt-4');
-      expect(model?.label).toBe('GPT-4');
-    });
-
-    it('should return model using fallback logic when exact match not found', () => {
-      // split('/', 2) limits to 2 parts, so 'some/prefix/gpt-4' becomes ['some', 'prefix/gpt-4']
-      // The fallback looks for models ending with 'prefix/gpt-4', which won't match 'openai/gpt-4'
-      // So this test should expect undefined, or we need to test with a 2-part ID
-      const model = modelStore.getModelById('some/gpt-4');
-      expect(model).toBeDefined();
-      expect(model?.id).toBe('openai/gpt-4');
-    });
-
-    it('should return model using fallback when ID has no provider information', () => {
-      const model = modelStore.getModelById('claude-3-opus');
-      expect(model).toBeDefined();
-      expect(model?.id).toBe('anthropic/claude-3-opus');
-    });
-    it('should return model when ID has provider info, but model list does not', () => {
-        const model = modelStore.getModelById('custom/simple-model');
-        expect(model).toBeDefined();
-        expect(model?.id).toBe('simple-model');
-    });
-
-    it('should return undefined when model not found', () => {
-      // Note: empty string ID will match any model because endsWith('') is always true
-      // So we test with a clearly non-matching ID
-      const model = modelStore.getModelById('nonexistent/definitely-not-a-model');
-      expect(model).toBeUndefined();
-    });
-
-    it('should return first model for empty string ID (endsWith edge case)', () => {
-      // Empty string causes split('/') to return [''], and endsWith('') matches all strings
-      // This is a known edge case in the implementation
-      const model = modelStore.getModelById('');
-      expect(model).toBeDefined(); // Will match first model due to endsWith('') behavior
-    });
-
-    it('should handle ID without slash (no fallback needed)', () => {
-      const model = modelStore.getModelById('simple-model');
-      expect(model).toBeDefined();
-      expect(model?.id).toBe('simple-model');
-    });
-
-    it('should handle ID with only one segment (no slash)', () => {
-      // When split('/') returns array with one element, idData[idData.length - 1] is that element
-      const model = modelStore.getModelById('simple-model');
-      expect(model).toBeDefined();
-      expect(model?.id).toBe('simple-model');
-    });
-
-    it('should prefer exact match over fallback', () => {
-      // If we have both exact match and a model that would match fallback
-      modelStore.setModels([
-        createMockModel('openai/gpt-4', 'GPT-4', 'openai'),
-        createMockModel('custom/gpt-4', 'Custom GPT-4', 'custom')
-      ]);
-
-      const model = modelStore.getModelById('openai/gpt-4');
-      expect(model?.id).toBe('openai/gpt-4'); // Should get exact match
-    });
-  });
-
-  describe('getProviders', () => {
-    it('should return empty array when no models are set', () => {
-      expect(modelStore.getProviders()).toEqual([]);
-    });
-
-    it('should return unique providers from models', () => {
-      modelStore.setModels([
-        createMockModel('openai/gpt-4', 'GPT-4', 'openai'),
-        createMockModel('openai/gpt-3.5', 'GPT-3.5', 'openai'),
-        createMockModel('anthropic/claude-3', 'Claude 3', 'anthropic')
-      ]);
-
-      const providers = modelStore.getProviders();
-      expect(providers).toHaveLength(2);
-      expect(providers).toContain('openai');
-      expect(providers).toContain('anthropic');
-    });
-
-    it('should not include duplicates', () => {
-      modelStore.setModels([
-        createMockModel('openai/gpt-4', 'GPT-4', 'openai'),
-        createMockModel('openai/gpt-3.5', 'GPT-3.5', 'openai'),
-        createMockModel('openai/gpt-4-turbo', 'GPT-4 Turbo', 'openai')
-      ]);
-
-      const providers = modelStore.getProviders();
-      expect(providers).toHaveLength(1);
-      expect(providers).toEqual(['openai']);
-    });
-
-    it('should exclude models without provider', () => {
-      modelStore.setModels([
-        createMockModel('model-1', 'Model 1'), // No provider
-        createMockModel('openai/gpt-4', 'GPT-4', 'openai'),
-        createMockModel('model-2', 'Model 2') // No provider
-      ]);
-
-      const providers = modelStore.getProviders();
-      expect(providers).toEqual(['openai']);
-    });
-
-    it('should return empty array when all models have no provider', () => {
-      modelStore.setModels([
-        createMockModel('model-1', 'Model 1'),
-        createMockModel('model-2', 'Model 2')
-      ]);
-
-      const providers = modelStore.getProviders();
-      expect(providers).toEqual([]);
-    });
-  });
-
-  describe('getLastFetched', () => {
-    it('should return null when no models have been set', () => {
-      expect(modelStore.getLastFetched()).toBeNull();
-    });
-
-    it('should return date when models have been set', () => {
-      const models: ModelOption[] = [
-        createMockModel('openai/gpt-4', 'GPT-4', 'openai')
-      ];
-
-      modelStore.setModels(models);
-      const lastFetched = modelStore.getLastFetched();
-
-      expect(lastFetched).not.toBeNull();
-      expect(lastFetched).toBeInstanceOf(Date);
-    });
-
-    it('should return null after clear()', () => {
-      modelStore.setModels([
-        createMockModel('openai/gpt-4', 'GPT-4', 'openai')
-      ]);
-      expect(modelStore.getLastFetched()).not.toBeNull();
-
-      modelStore.clear();
-      expect(modelStore.getLastFetched()).toBeNull();
-    });
-
-    it('should update timestamp when setModels is called again', async () => {
-      const models: ModelOption[] = [
-        createMockModel('openai/gpt-4', 'GPT-4', 'openai')
-      ];
-
-      modelStore.setModels(models);
-      const firstTimestamp = modelStore.getLastFetched()!.getTime();
-
-      // Wait a small amount to ensure different timestamp
-      await new Promise((resolve) => setTimeout(resolve, 10));
-
-      modelStore.setModels(models);
-      const secondTimestamp = modelStore.getLastFetched()!.getTime();
-
-      expect(secondTimestamp).toBeGreaterThan(firstTimestamp);
-    });
-  });
-
-  describe('hasModels', () => {
-    it('should return false when no models are set', () => {
-      expect(modelStore.hasModels()).toBe(false);
-    });
-
-    it('should return true when models are set', () => {
-      modelStore.setModels([
-        createMockModel('openai/gpt-4', 'GPT-4', 'openai')
-      ]);
-      expect(modelStore.hasModels()).toBe(true);
-    });
-
-    it('should return false after clear()', () => {
-      modelStore.setModels([
-        createMockModel('openai/gpt-4', 'GPT-4', 'openai')
-      ]);
-      expect(modelStore.hasModels()).toBe(true);
-
-      modelStore.clear();
-      expect(modelStore.hasModels()).toBe(false);
-    });
-
-    it('should return false when empty array is set', () => {
-      modelStore.setModels([]);
-      expect(modelStore.hasModels()).toBe(false);
-    });
-  });
-
-  describe('clear', () => {
-    it('should clear all models', () => {
-      modelStore.setModels([
-        createMockModel('openai/gpt-4', 'GPT-4', 'openai'),
-        createMockModel('anthropic/claude-3', 'Claude 3', 'anthropic')
-      ]);
-
-      expect(modelStore.hasModels()).toBe(true);
-      modelStore.clear();
-      expect(modelStore.hasModels()).toBe(false);
-      expect(modelStore.getModels()).toEqual([]);
-    });
-
-    it('should reset lastFetched to null', () => {
-      modelStore.setModels([
-        createMockModel('openai/gpt-4', 'GPT-4', 'openai')
-      ]);
-
-      expect(modelStore.getLastFetched()).not.toBeNull();
-      modelStore.clear();
-      expect(modelStore.getLastFetched()).toBeNull();
-    });
-
-    it('should be safe to call when store is already empty', () => {
-      expect(() => modelStore.clear()).not.toThrow();
-      expect(modelStore.hasModels()).toBe(false);
-    });
-
-    it('should clear providers list', () => {
-      modelStore.setModels([
-        createMockModel('openai/gpt-4', 'GPT-4', 'openai')
-      ]);
-
-      expect(modelStore.getProviders()).toHaveLength(1);
-      modelStore.clear();
-      expect(modelStore.getProviders()).toEqual([]);
-    });
-  });
-
-  describe('integration scenarios', () => {
-    it('should handle complete workflow: set, query, clear, set again', () => {
-      // Initial state
-      expect(modelStore.hasModels()).toBe(false);
-      expect(modelStore.getModels()).toEqual([]);
-
-      // Set models
-      const models1: ModelOption[] = [
-        createMockModel('openai/gpt-4', 'GPT-4', 'openai'),
-        createMockModel('anthropic/claude-3', 'Claude 3', 'anthropic')
-      ];
-      modelStore.setModels(models1);
-
-      expect(modelStore.hasModels()).toBe(true);
-      expect(modelStore.getModels()).toHaveLength(2);
-      expect(modelStore.getProviders()).toHaveLength(2);
-      expect(modelStore.getModelById('openai/gpt-4')).toBeDefined();
-
-      // Clear
-      modelStore.clear();
-      expect(modelStore.hasModels()).toBe(false);
-      expect(modelStore.getModels()).toEqual([]);
-      expect(modelStore.getProviders()).toEqual([]);
-
-      // Set again
-      const models2: ModelOption[] = [
-        createMockModel('google/gemini-pro', 'Gemini Pro', 'google')
-      ];
-      modelStore.setModels(models2);
-
-      expect(modelStore.hasModels()).toBe(true);
-      expect(modelStore.getModels()).toHaveLength(1);
-      expect(modelStore.getProviders()).toEqual(['google']);
-    });
-
-    it('should handle models with all optional fields', () => {
-      const complexModels: ModelOption[] = [
-        {
-          id: 'openai/gpt-4',
-          label: 'GPT-4',
-          provider: 'openai',
-          reasoning: 'deep',
-          contexts: ['context1', 'context2'],
-          description: 'A powerful model'
-        },
-        {
-          id: 'anthropic/claude-3',
-          label: 'Claude 3',
-          provider: 'anthropic',
-          reasoning: 'concise',
-          contexts: ['context1']
-        },
-        {
-          id: 'simple-model',
-          label: 'Simple'
-          // No optional fields
-        }
-      ];
-
-      modelStore.setModels(complexModels);
-
-      expect(modelStore.getModels()).toHaveLength(3);
-      expect(modelStore.getProviders()).toHaveLength(2); // Only 2 have providers
-
-      const gpt4 = modelStore.getModelById('openai/gpt-4');
-      expect(gpt4?.reasoning).toBe('deep');
-      expect(gpt4?.contexts).toEqual(['context1', 'context2']);
-      expect(gpt4?.description).toBe('A powerful model');
-    });
-  });
-});

package/src/store/ModelStore.ts

@@ -1,93 +0,0 @@
-import type { ModelOption } from '@multiplayer-app/ai-agent-types';
-import { logger } from '../libs/logger';
-import { ConfigStore } from './ConfigStore';
-
-export class ModelStore {
-  private static instance: ModelStore;
-  private models: ModelOption[] = [];
-  private lastFetched: Date | null = null;
-
-  private constructor() {}
-
-  /**
-   * Get the singleton instance of ModelStore
-   */
-  static getInstance(): ModelStore {
-    if (!ModelStore.instance) {
-      ModelStore.instance = new ModelStore();
-    }
-    return ModelStore.instance;
-  }
-
-  /**
-   * Set models in the store
-   */
-  setModels(models: ModelOption[]): void {
-    this.models = models.filter((model) => ConfigStore.getInstance().isModelAllowed(model.id, model.provider));
-    this.lastFetched = new Date();
-    logger.info(`Loaded ${models.length} models, available after filtering: ${this.models.length} from ${this.getProviders().length} providers`);
-  }
-
-  /**
-   * Get all models
-   */
-  getModels(): ModelOption[] {
-    return this.models;
-  }
-
-  /**
-   * Get models by provider
-   */
-  getModelsByProvider(provider: string): ModelOption[] {
-    return this.models.filter((model) => model.provider === provider);
-  }
-
-  /**
-   * Get a specific model by ID
-   */
-  getModelById(id: string): ModelOption | undefined {
-    const found = this.models.find((model) => model.id === id);
-
-    if (found) {
-      return found;
-    }
-    const idData = id.split('/', 2)
-    const modelName = idData[idData.length - 1];
-    return this.models.find((model) => model.id.endsWith(modelName));
-  }
-
-  /**
-   * Get all unique providers
-   */
-  getProviders(): string[] {
-    const providers = new Set<string>();
-    for (const model of this.models) {
-      if (model.provider) {
-        providers.add(model.provider);
-      }
-    }
-    return Array.from(providers);
-  }
-
-  /**
-   * Get when models were last fetched
-   */
-  getLastFetched(): Date | null {
-    return this.lastFetched;
-  }
-
-  /**
-   * Check if models have been loaded
-   */
-  hasModels(): boolean {
-    return this.models.length > 0;
-  }
-
-  /**
-   * Clear all models
-   */
-  clear(): void {
-    this.models = [];
-    this.lastFetched = null;
-  }
-}

package/src/store/index.ts

@@ -1,4 +0,0 @@
-export * from './ConfigStore';
-export * from './AgentStore';
-export * from './ArtifactStore';
-export * from './ModelStore';