Skip to content

Turn meetings into live agent loops. Record, transcribe, and analyze meetings with real-time AI intelligence — before, during, and after calls.

7.5 KB
Raw Blame
/**
 * MCP Store
 *
 * Centralized state management for MCP (Model Context Protocol) features:
 * - Server configurations
 * - Connection states
 * - Available tools
 * - Active results
 * - Templates
 */

import { create } from 'zustand';
import type {
  MCPServerConfig,
  MCPTool,
  MCPDisplayResult,
  MCPServerTemplate,
} from '../../preload/index';

// Types

export type MCPConnectionStatus = 'disconnected' | 'connecting' | 'connected' | 'error';

export interface MCPState {
  // Server management
  servers: MCPServerConfig[];
  templates: MCPServerTemplate[];

  // Connection state
  connectionStates: Record<string, { status: MCPConnectionStatus; error?: string }>;

  // Available tools (aggregated from all connected servers)
  availableTools: MCPTool[];

  // Active results to display
  activeResults: MCPDisplayResult[];

  // Pending tool calls
  pendingCalls: Set<string>;

  // Configuration
  isInitialized: boolean;
  autoTriggerEnabled: boolean;

  // Custom trigger keywords for MCP agent
  customTriggerKeywords: string[];

  // Error state
  lastError?: string;

  // Actions
  setInitialized: (value: boolean) => void;
  setAutoTriggerEnabled: (value: boolean) => void;
  setCustomTriggerKeywords: (keywords: string[]) => void;

  // Server actions
  setServers: (servers: MCPServerConfig[]) => void;
  addServer: (server: MCPServerConfig) => void;
  updateServer: (serverId: string, updates: Partial<MCPServerConfig>) => void;
  removeServer: (serverId: string) => void;

  // Template actions
  setTemplates: (templates: MCPServerTemplate[]) => void;

  // Connection state actions
  setConnectionStates: (states: Record<string, { status: MCPConnectionStatus; error?: string }>) => void;
  updateConnectionState: (serverId: string, status: MCPConnectionStatus, error?: string) => void;

  // Tool actions
  setAvailableTools: (tools: MCPTool[]) => void;
  addToolsFromServer: (serverId: string, tools: MCPTool[]) => void;
  removeToolsFromServer: (serverId: string) => void;

  // Result actions
  addResult: (result: MCPDisplayResult) => void;
  dismissResult: (resultId: string) => void;
  pinResult: (resultId: string) => void;
  clearResults: () => void;

  // Pending calls actions
  addPendingCall: (callId: string) => void;
  removePendingCall: (callId: string) => void;

  // Error actions
  setError: (error: string | undefined) => void;

  // Reset
  reset: () => void;
}

// Initial State

const initialState = {
  servers: [] as MCPServerConfig[],
  templates: [] as MCPServerTemplate[],
  connectionStates: {} as Record<string, { status: MCPConnectionStatus; error?: string }>,
  availableTools: [] as MCPTool[],
  activeResults: [] as MCPDisplayResult[],
  pendingCalls: new Set<string>(),
  isInitialized: false,
  autoTriggerEnabled: true,
  customTriggerKeywords: [] as string[],
  lastError: undefined,
};

// Store

export const useMCPStore = create<MCPState>((set, get) => ({
  ...initialState,

  // Initialization
  setInitialized: (value) => set({ isInitialized: value }),
  setAutoTriggerEnabled: (value) => set({ autoTriggerEnabled: value }),
  setCustomTriggerKeywords: (keywords) => set({ customTriggerKeywords: keywords }),

  // Server management
  setServers: (servers) => set({ servers }),

  addServer: (server) => {
    set((state) => ({
      servers: [...state.servers, server],
    }));
  },

  updateServer: (serverId, updates) => {
    set((state) => ({
      servers: state.servers.map((s) =>
        s.id === serverId ? { ...s, ...updates } : s
      ),
    }));
  },

  removeServer: (serverId) => {
    const { removeToolsFromServer } = get();
    removeToolsFromServer(serverId);

    set((state) => ({
      servers: state.servers.filter((s) => s.id !== serverId),
      connectionStates: Object.fromEntries(
        Object.entries(state.connectionStates).filter(([id]) => id !== serverId)
      ),
    }));
  },

  // Templates
  setTemplates: (templates) => set({ templates }),

  // Connection states
  setConnectionStates: (states) => set({ connectionStates: states }),

  updateConnectionState: (serverId, status, error) => {
    set((state) => ({
      connectionStates: {
        ...state.connectionStates,
        [serverId]: { status, error },
      },
    }));
  },

  // Tools
  setAvailableTools: (tools) => set({ availableTools: tools }),

  addToolsFromServer: (serverId, tools) => {
    set((state) => {
      // Remove existing tools from this server, then add new ones
      const existingTools = state.availableTools.filter((t) => t.serverId !== serverId);
      return {
        availableTools: [...existingTools, ...tools],
      };
    });
  },

  removeToolsFromServer: (serverId) => {
    set((state) => ({
      availableTools: state.availableTools.filter((t) => t.serverId !== serverId),
    }));
  },

  // Results
  addResult: (result) => {
    set((state) => {
      if (state.activeResults.some((existing) => existing.id === result.id)) {
        return state;
      }
      return {
        activeResults: [...state.activeResults, result],
      };
    });
  },

  dismissResult: (resultId) => {
    set((state) => ({
      activeResults: state.activeResults.map((r) =>
        r.id === resultId ? { ...r, dismissed: true } : r
      ),
    }));
  },

  pinResult: (resultId) => {
    set((state) => ({
      activeResults: state.activeResults.map((r) =>
        r.id === resultId ? { ...r, pinned: true } : r
      ),
    }));
  },

  clearResults: () => {
    set({ activeResults: [] });
  },

  // Pending calls
  addPendingCall: (callId) => {
    set((state) => ({
      pendingCalls: new Set([...state.pendingCalls, callId]),
    }));
  },

  removePendingCall: (callId) => {
    set((state) => {
      const newPending = new Set(state.pendingCalls);
      newPending.delete(callId);
      return { pendingCalls: newPending };
    });
  },

  // Errors
  setError: (error) => set({ lastError: error }),

  // Reset
  reset: () => {
    set({
      ...initialState,
      pendingCalls: new Set(),
    });
  },
}));

// Selectors (for optimized re-renders)

export const selectServers = (state: MCPState) => state.servers;
export const selectTemplates = (state: MCPState) => state.templates;
export const selectConnectionStates = (state: MCPState) => state.connectionStates;
export const selectAvailableTools = (state: MCPState) => state.availableTools;
export const selectActiveResults = (state: MCPState) => state.activeResults;
export const selectVisibleResults = (state: MCPState) =>
  state.activeResults.filter((r) => !r.dismissed);
export const selectPinnedResults = (state: MCPState) =>
  state.activeResults.filter((r) => r.pinned && !r.dismissed);
export const selectPendingCalls = (state: MCPState) => state.pendingCalls;
export const selectIsInitialized = (state: MCPState) => state.isInitialized;
export const selectAutoTriggerEnabled = (state: MCPState) => state.autoTriggerEnabled;
export const selectCustomTriggerKeywords = (state: MCPState) => state.customTriggerKeywords;
export const selectLastError = (state: MCPState) => state.lastError;

// Computed selectors
export const selectConnectedServerCount = (state: MCPState) =>
  Object.values(state.connectionStates).filter((s) => s.status === 'connected').length;

export const selectToolCount = (state: MCPState) => state.availableTools.length;

export const selectServerById = (serverId: string) => (state: MCPState) =>
  state.servers.find((s) => s.id === serverId);

export const selectConnectionStateById = (serverId: string) => (state: MCPState) =>
  state.connectionStates[serverId];

export const selectToolsByServer = (serverId: string) => (state: MCPState) =>
  state.availableTools.filter((t) => t.serverId === serverId);