Method discoverTools

apps/sim/lib/mcp/service.ts:423–598

(
    userId: string,
    workspaceId: string,
    forceRefresh = false
  )

  }

  async discoverTools(
    userId: string,
    workspaceId: string,
    forceRefresh = false
  ): Promise<McpTool[]> {
    const requestId = generateRequestId()

    try {
      logger.info(`[${requestId}] Discovering MCP tools for workspace ${workspaceId}`)

      const servers = await this.getWorkspaceServers(workspaceId)

      if (servers.length === 0) {
        logger.info(`[${requestId}] No servers found for workspace ${workspaceId}`)
        return []
      }

      const outcomes = await Promise.all(
        servers.map(async (config): Promise<DiscoveryOutcome> => {
          const cacheKey = serverCacheKey(workspaceId, config.id)

          if (!forceRefresh) {
            try {
              const cached = await this.cacheAdapter.get(cacheKey)
              if (cached) return { kind: 'cached', tools: cached.tools }
            } catch (error) {
              logger.warn(
                `[${requestId}] Cache read failed for ${config.name}, proceeding with discovery:`,
                error
              )
            }
            if (await this.isServerUnhealthy(workspaceId, config.id)) {
              logger.info(
                `[${requestId}] Skipping recently-failed server ${config.name} (negative-cache hit)`
              )
              return { kind: 'unhealthy' }
            }
          }

          try {
            const { config: resolvedConfig, resolvedIP } = await this.resolveConfigEnvVars(
              config,
              userId,
              workspaceId
            )
            const client = await this.createClient(resolvedConfig, resolvedIP, userId)
            try {
              const tools = await client.listTools()
              logger.debug(
                `[${requestId}] Discovered ${tools.length} tools from server ${config.name}`
              )
              return { kind: 'fetched', tools, resolvedConfig, resolvedIP }
            } finally {
              await client.disconnect()
            }
          } catch (error) {
            if (
              error instanceof McpOauthAuthorizationRequiredError ||