feat: Support Cherry Studio as a Service (CSaaS) (#8098)

src/main/apiServer/utils/index.ts

@@ -0,0 +1,111 @@
+import { loggerService } from '@main/services/LoggerService'
+import { reduxService } from '@main/services/ReduxService'
+import { Model, Provider } from '@types'
+
+const logger = loggerService.withContext('ApiServerUtils')
+
+// OpenAI compatible model format
+export interface OpenAICompatibleModel {
+  id: string
+  object: 'model'
+  created: number
+  owned_by: string
+}
+
+export async function getAvailableProviders(): Promise<Provider[]> {
+  try {
+    // Wait for store to be ready before accessing providers
+    const providers = await reduxService.select('state.llm.providers')
+    if (!providers || !Array.isArray(providers)) {
+      logger.warn('No providers found in Redux store, returning empty array')
+      return []
+    }
+    return providers.filter((p: Provider) => p.enabled)
+  } catch (error: any) {
+    logger.error('Failed to get providers from Redux store:', error)
+    return []
+  }
+}
+
+export async function listAllAvailableModels(): Promise<Model[]> {
+  try {
+    const providers = await getAvailableProviders()
+    return providers.map((p: Provider) => p.models || []).flat() as Model[]
+  } catch (error: any) {
+    logger.error('Failed to list available models:', error)
+    return []
+  }
+}
+
+export async function getProviderByModel(model: string): Promise<Provider | undefined> {
+  try {
+    if (!model || typeof model !== 'string') {
+      logger.warn(`Invalid model parameter: ${model}`)
+      return undefined
+    }
+
+    const providers = await getAvailableProviders()
+    const modelInfo = model.split(':')
+
+    if (modelInfo.length < 2) {
+      logger.warn(`Invalid model format, expected "provider:model": ${model}`)
+      return undefined
+    }
+
+    const providerId = modelInfo[0]
+    const provider = providers.find((p: Provider) => p.id === providerId)
+
+    if (!provider) {
+      logger.warn(`Provider not found for model: ${model}`)
+      return undefined
+    }
+
+    return provider
+  } catch (error: any) {
+    logger.error('Failed to get provider by model:', error)
+    return undefined
+  }
+}
+
+export function getRealProviderModel(modelStr: string): string {
+  return modelStr.split(':').slice(1).join(':')
+}
+
+export function transformModelToOpenAI(model: Model): OpenAICompatibleModel {
+  return {
+    id: `${model.provider}:${model.id}`,
+    object: 'model',
+    created: Math.floor(Date.now() / 1000),
+    owned_by: model.owned_by || model.provider
+  }
+}
+
+export function validateProvider(provider: Provider): boolean {
+  try {
+    if (!provider) {
+      return false
+    }
+
+    // Check required fields
+    if (!provider.id || !provider.type || !provider.apiKey || !provider.apiHost) {
+      logger.warn('Provider missing required fields:', {
+        id: !!provider.id,
+        type: !!provider.type,
+        apiKey: !!provider.apiKey,
+        apiHost: !!provider.apiHost
+      })
+      return false
+    }
+
+    // Check if provider is enabled
+    if (!provider.enabled) {
+      logger.debug(`Provider is disabled: ${provider.id}`)
+      return false
+    }
+
+    return true
+  } catch (error: any) {
+    logger.error('Error validating provider:', error)
+    return false
+  }
+}

src/main/apiServer/utils/mcp.ts

@@ -0,0 +1,76 @@
+import mcpService from '@main/services/MCPService'
+import { Server } from '@modelcontextprotocol/sdk/server/index.js'
+import { CallToolRequestSchema, ListToolsRequestSchema, ListToolsResult } from '@modelcontextprotocol/sdk/types.js'
+import { MCPServer } from '@types'
+
+import { loggerService } from '../../services/LoggerService'
+import { reduxService } from '../../services/ReduxService'
+
+const logger = loggerService.withContext('MCPApiService')
+
+const cachedServers: Record<string, Server> = {}
+
+async function handleListToolsRequest(request: any, extra: any): Promise<ListToolsResult> {
+  logger.debug('Handling list tools request', { request: request, extra: extra })
+  const serverId: string = request.params._meta.serverId
+  const serverConfig = await getMcpServerConfigById(serverId)
+  if (!serverConfig) {
+    throw new Error(`Server not found: ${serverId}`)
+  }
+  const client = await mcpService.initClient(serverConfig)
+  return await client.listTools()
+}
+
+async function handleCallToolRequest(request: any, extra: any): Promise<any> {
+  logger.debug('Handling call tool request', { request: request, extra: extra })
+  const serverId: string = request.params._meta.serverId
+  const serverConfig = await getMcpServerConfigById(serverId)
+  if (!serverConfig) {
+    throw new Error(`Server not found: ${serverId}`)
+  }
+  const client = await mcpService.initClient(serverConfig)
+  return client.callTool(request.params)
+}
+
+async function getMcpServerConfigById(id: string): Promise<MCPServer | undefined> {
+  const servers = await getServersFromRedux()
+  return servers.find((s) => s.id === id || s.name === id)
+}
+
+/**
+ * Get servers directly from Redux store
+ */
+async function getServersFromRedux(): Promise<MCPServer[]> {
+  try {
+    const servers = await reduxService.select<MCPServer[]>('state.mcp.servers')
+    logger.silly(`Fetched ${servers?.length || 0} servers from Redux store`)
+    return servers || []
+  } catch (error: any) {
+    logger.error('Failed to get servers from Redux:', error)
+    return []
+  }
+}
+
+export async function getMcpServerById(id: string): Promise<Server> {
+  const server = cachedServers[id]
+  if (!server) {
+    const servers = await getServersFromRedux()
+    const mcpServer = servers.find((s) => s.id === id || s.name === id)
+    if (!mcpServer) {
+      throw new Error(`Server not found: ${id}`)
+    }
+
+    const createMcpServer = (name: string, version: string): Server => {
+      const server = new Server({ name: name, version }, { capabilities: { tools: {} } })
+      server.setRequestHandler(ListToolsRequestSchema, handleListToolsRequest)
+      server.setRequestHandler(CallToolRequestSchema, handleCallToolRequest)
+      return server
+    }
+
+    const newServer = createMcpServer(mcpServer.name, '0.1.0')
+    cachedServers[id] = newServer
+    return newServer
+  }
+  logger.silly('getMcpServer ', { server: server })
+  return server
+}